chore: rename server to api (#7342)

apps/api/plane/api/apps.py

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

apps/api/plane/api/middleware/api_authentication.py

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

apps/api/plane/api/rate_limit.py

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

apps/api/plane/api/serializers/__init__.py

@@ -0,0 +1,18 @@
+from .user import UserLiteSerializer
+from .workspace import WorkspaceLiteSerializer
+from .project import ProjectSerializer, ProjectLiteSerializer
+from .issue import (
+    IssueSerializer,
+    LabelSerializer,
+    IssueLinkSerializer,
+    IssueCommentSerializer,
+    IssueAttachmentSerializer,
+    IssueActivitySerializer,
+    IssueExpandSerializer,
+    IssueLiteSerializer,
+)
+from .state import StateLiteSerializer, StateSerializer
+from .cycle import CycleSerializer, CycleIssueSerializer, CycleLiteSerializer
+from .module import ModuleSerializer, ModuleIssueSerializer, ModuleLiteSerializer
+from .intake import IntakeIssueSerializer
+from .estimate import EstimatePointSerializer

apps/api/plane/api/serializers/base.py

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

apps/api/plane/api/serializers/cycle.py

@@ -0,0 +1,90 @@
+# Third party imports
+import pytz
+from rest_framework import serializers
+
+# Module imports
+from .base import BaseSerializer
+from plane.db.models import Cycle, CycleIssue
+from plane.utils.timezone_converter import convert_to_utc
+
+
+class CycleSerializer(BaseSerializer):
+    total_issues = serializers.IntegerField(read_only=True)
+    cancelled_issues = serializers.IntegerField(read_only=True)
+    completed_issues = serializers.IntegerField(read_only=True)
+    started_issues = serializers.IntegerField(read_only=True)
+    unstarted_issues = serializers.IntegerField(read_only=True)
+    backlog_issues = serializers.IntegerField(read_only=True)
+    total_estimates = serializers.FloatField(read_only=True)
+    completed_estimates = serializers.FloatField(read_only=True)
+    started_estimates = serializers.FloatField(read_only=True)
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        project = self.context.get("project")
+        if project and project.timezone:
+            project_timezone = pytz.timezone(project.timezone)
+            self.fields["start_date"].timezone = project_timezone
+            self.fields["end_date"].timezone = project_timezone
+
+    def validate(self, data):
+        if (
+            data.get("start_date", None) is not None
+            and data.get("end_date", None) is not None
+            and data.get("start_date", None) > data.get("end_date", None)
+        ):
+            raise serializers.ValidationError("Start date cannot exceed end date")
+
+        if (
+            data.get("start_date", None) is not None
+            and data.get("end_date", None) is not None
+        ):
+            project_id = self.initial_data.get("project_id") or (
+                self.instance.project_id
+                if self.instance and hasattr(self.instance, "project_id")
+                else None
+            )
+
+            if not project_id:
+                raise serializers.ValidationError("Project ID is required")
+
+            data["start_date"] = convert_to_utc(
+                date=str(data.get("start_date").date()),
+                project_id=project_id,
+                is_start_date=True,
+            )
+            data["end_date"] = convert_to_utc(
+                date=str(data.get("end_date", None).date()),
+                project_id=project_id,
+            )
+        return data
+
+    class Meta:
+        model = Cycle
+        fields = "__all__"
+        read_only_fields = [
+            "id",
+            "created_at",
+            "updated_at",
+            "created_by",
+            "updated_by",
+            "workspace",
+            "project",
+            "owned_by",
+            "deleted_at",
+        ]
+
+
+class CycleIssueSerializer(BaseSerializer):
+    sub_issues_count = serializers.IntegerField(read_only=True)
+
+    class Meta:
+        model = CycleIssue
+        fields = "__all__"
+        read_only_fields = ["workspace", "project", "cycle"]
+
+
+class CycleLiteSerializer(BaseSerializer):
+    class Meta:
+        model = Cycle
+        fields = "__all__"

apps/api/plane/api/serializers/estimate.py

@@ -0,0 +1,10 @@
+# Module imports
+from plane.db.models import EstimatePoint
+from .base import BaseSerializer
+
+
+class EstimatePointSerializer(BaseSerializer):
+    class Meta:
+        model = EstimatePoint
+        fields = ["id", "value"]
+        read_only_fields = fields

apps/api/plane/api/serializers/intake.py

@@ -0,0 +1,24 @@
+# Module improts
+from .base import BaseSerializer
+from .issue import IssueExpandSerializer
+from plane.db.models import IntakeIssue
+from rest_framework import serializers
+
+
+class IntakeIssueSerializer(BaseSerializer):
+    issue_detail = IssueExpandSerializer(read_only=True, source="issue")
+    inbox = serializers.UUIDField(source="intake.id", read_only=True)
+
+    class Meta:
+        model = IntakeIssue
+        fields = "__all__"
+        read_only_fields = [
+            "id",
+            "workspace",
+            "project",
+            "issue",
+            "created_by",
+            "updated_by",
+            "created_at",
+            "updated_at",
+        ]

apps/api/plane/api/serializers/issue.py

@@ -0,0 +1,466 @@
+# Django imports
+from django.utils import timezone
+from lxml import html
+from django.db import IntegrityError
+
+#  Third party imports
+from rest_framework import serializers
+
+# Module imports
+from plane.db.models import (
+    Issue,
+    IssueType,
+    IssueActivity,
+    IssueAssignee,
+    FileAsset,
+    IssueComment,
+    IssueLabel,
+    IssueLink,
+    Label,
+    ProjectMember,
+    State,
+    User,
+)
+
+from .base import BaseSerializer
+from .cycle import CycleLiteSerializer, CycleSerializer
+from .module import ModuleLiteSerializer, ModuleSerializer
+from .state import StateLiteSerializer
+from .user import UserLiteSerializer
+
+# Django imports
+from django.core.exceptions import ValidationError
+from django.core.validators import URLValidator
+
+
+class IssueSerializer(BaseSerializer):
+    assignees = serializers.ListField(
+        child=serializers.PrimaryKeyRelatedField(
+            queryset=User.objects.values_list("id", flat=True)
+        ),
+        write_only=True,
+        required=False,
+    )
+
+    labels = serializers.ListField(
+        child=serializers.PrimaryKeyRelatedField(
+            queryset=Label.objects.values_list("id", flat=True)
+        ),
+        write_only=True,
+        required=False,
+    )
+    type_id = serializers.PrimaryKeyRelatedField(
+        source="type", queryset=IssueType.objects.all(), required=False, allow_null=True
+    )
+
+    class Meta:
+        model = Issue
+        read_only_fields = ["id", "workspace", "project", "updated_by", "updated_at"]
+        exclude = ["description", "description_stripped"]
+
+    def validate(self, data):
+        if (
+            data.get("start_date", None) is not None
+            and data.get("target_date", None) is not None
+            and data.get("start_date", None) > data.get("target_date", None)
+        ):
+            raise serializers.ValidationError("Start date cannot exceed target date")
+
+        try:
+            if data.get("description_html", None) is not None:
+                parsed = html.fromstring(data["description_html"])
+                parsed_str = html.tostring(parsed, encoding="unicode")
+                data["description_html"] = parsed_str
+
+        except Exception:
+            raise serializers.ValidationError("Invalid HTML passed")
+
+        # Validate assignees are from project
+        if data.get("assignees", []):
+            data["assignees"] = ProjectMember.objects.filter(
+                project_id=self.context.get("project_id"),
+                is_active=True,
+                role__gte=15,
+                member_id__in=data["assignees"],
+            ).values_list("member_id", flat=True)
+
+        # Validate labels are from project
+        if data.get("labels", []):
+            data["labels"] = Label.objects.filter(
+                project_id=self.context.get("project_id"), id__in=data["labels"]
+            ).values_list("id", flat=True)
+
+        # Check state is from the project only else raise validation error
+        if (
+            data.get("state")
+            and not State.objects.filter(
+                project_id=self.context.get("project_id"), pk=data.get("state").id
+            ).exists()
+        ):
+            raise serializers.ValidationError(
+                "State is not valid please pass a valid state_id"
+            )
+
+        # Check parent issue is from workspace as it can be cross workspace
+        if (
+            data.get("parent")
+            and not Issue.objects.filter(
+                workspace_id=self.context.get("workspace_id"), pk=data.get("parent").id
+            ).exists()
+        ):
+            raise serializers.ValidationError(
+                "Parent is not valid issue_id please pass a valid issue_id"
+            )
+
+        return data
+
+    def create(self, validated_data):
+        assignees = validated_data.pop("assignees", None)
+        labels = validated_data.pop("labels", None)
+
+        project_id = self.context["project_id"]
+        workspace_id = self.context["workspace_id"]
+        default_assignee_id = self.context["default_assignee_id"]
+
+        issue_type = validated_data.pop("type", None)
+
+        if not issue_type:
+            # Get default issue type
+            issue_type = IssueType.objects.filter(
+                project_issue_types__project_id=project_id, is_default=True
+            ).first()
+            issue_type = issue_type
+
+        issue = Issue.objects.create(
+            **validated_data, project_id=project_id, type=issue_type
+        )
+
+        # Issue Audit Users
+        created_by_id = issue.created_by_id
+        updated_by_id = issue.updated_by_id
+
+        if assignees is not None and len(assignees):
+            try:
+                IssueAssignee.objects.bulk_create(
+                    [
+                        IssueAssignee(
+                            assignee_id=assignee_id,
+                            issue=issue,
+                            project_id=project_id,
+                            workspace_id=workspace_id,
+                            created_by_id=created_by_id,
+                            updated_by_id=updated_by_id,
+                        )
+                        for assignee_id in assignees
+                    ],
+                    batch_size=10,
+                )
+            except IntegrityError:
+                pass
+        else:
+            try:
+                # Then assign it to default assignee, if it is a valid assignee
+                if (
+                    default_assignee_id is not None
+                    and ProjectMember.objects.filter(
+                        member_id=default_assignee_id,
+                        project_id=project_id,
+                        role__gte=15,
+                        is_active=True,
+                    ).exists()
+                ):
+                    IssueAssignee.objects.create(
+                        assignee_id=default_assignee_id,
+                        issue=issue,
+                        project_id=project_id,
+                        workspace_id=workspace_id,
+                        created_by_id=created_by_id,
+                        updated_by_id=updated_by_id,
+                    )
+            except IntegrityError:
+                pass
+
+        if labels is not None and len(labels):
+            try:
+                IssueLabel.objects.bulk_create(
+                    [
+                        IssueLabel(
+                            label_id=label_id,
+                            issue=issue,
+                            project_id=project_id,
+                            workspace_id=workspace_id,
+                            created_by_id=created_by_id,
+                            updated_by_id=updated_by_id,
+                        )
+                        for label_id in labels
+                    ],
+                    batch_size=10,
+                )
+            except IntegrityError:
+                pass
+
+        return issue
+
+    def update(self, instance, validated_data):
+        assignees = validated_data.pop("assignees", None)
+        labels = validated_data.pop("labels", None)
+
+        # Related models
+        project_id = instance.project_id
+        workspace_id = instance.workspace_id
+        created_by_id = instance.created_by_id
+        updated_by_id = instance.updated_by_id
+
+        if assignees is not None:
+            IssueAssignee.objects.filter(issue=instance).delete()
+            try:
+                IssueAssignee.objects.bulk_create(
+                    [
+                        IssueAssignee(
+                            assignee_id=assignee_id,
+                            issue=instance,
+                            project_id=project_id,
+                            workspace_id=workspace_id,
+                            created_by_id=created_by_id,
+                            updated_by_id=updated_by_id,
+                        )
+                        for assignee_id in assignees
+                    ],
+                    batch_size=10,
+                    ignore_conflicts=True,
+                )
+            except IntegrityError:
+                pass
+
+        if labels is not None:
+            IssueLabel.objects.filter(issue=instance).delete()
+            try:
+                IssueLabel.objects.bulk_create(
+                    [
+                        IssueLabel(
+                            label_id=label_id,
+                            issue=instance,
+                            project_id=project_id,
+                            workspace_id=workspace_id,
+                            created_by_id=created_by_id,
+                            updated_by_id=updated_by_id,
+                        )
+                        for label_id in labels
+                    ],
+                    batch_size=10,
+                    ignore_conflicts=True,
+                )
+            except IntegrityError:
+                pass
+
+        # Time updation occues even when other related models are updated
+        instance.updated_at = timezone.now()
+        return super().update(instance, validated_data)
+
+    def to_representation(self, instance):
+        data = super().to_representation(instance)
+        if "assignees" in self.fields:
+            if "assignees" in self.expand:
+                from .user import UserLiteSerializer
+
+                data["assignees"] = UserLiteSerializer(
+                    User.objects.filter(
+                        pk__in=IssueAssignee.objects.filter(issue=instance).values_list(
+                            "assignee_id", flat=True
+                        )
+                    ),
+                    many=True,
+                ).data
+            else:
+                data["assignees"] = [
+                    str(assignee)
+                    for assignee in IssueAssignee.objects.filter(
+                        issue=instance
+                    ).values_list("assignee_id", flat=True)
+                ]
+        if "labels" in self.fields:
+            if "labels" in self.expand:
+                data["labels"] = LabelSerializer(
+                    Label.objects.filter(
+                        pk__in=IssueLabel.objects.filter(issue=instance).values_list(
+                            "label_id", flat=True
+                        )
+                    ),
+                    many=True,
+                ).data
+            else:
+                data["labels"] = [
+                    str(label)
+                    for label in IssueLabel.objects.filter(issue=instance).values_list(
+                        "label_id", flat=True
+                    )
+                ]
+
+        return data
+
+
+class IssueLiteSerializer(BaseSerializer):
+    class Meta:
+        model = Issue
+        fields = ["id", "sequence_id", "project_id"]
+        read_only_fields = fields
+
+
+class LabelSerializer(BaseSerializer):
+    class Meta:
+        model = Label
+        fields = "__all__"
+        read_only_fields = [
+            "id",
+            "workspace",
+            "project",
+            "created_by",
+            "updated_by",
+            "created_at",
+            "updated_at",
+            "deleted_at",
+        ]
+
+
+class IssueLinkSerializer(BaseSerializer):
+    class Meta:
+        model = IssueLink
+        fields = "__all__"
+        read_only_fields = [
+            "id",
+            "workspace",
+            "project",
+            "issue",
+            "created_by",
+            "updated_by",
+            "created_at",
+            "updated_at",
+        ]
+
+    def validate_url(self, value):
+        # Check URL format
+        validate_url = URLValidator()
+        try:
+            validate_url(value)
+        except ValidationError:
+            raise serializers.ValidationError("Invalid URL format.")
+
+        # Check URL scheme
+        if not value.startswith(("http://", "https://")):
+            raise serializers.ValidationError("Invalid URL scheme.")
+
+        return value
+
+    # Validation if url already exists
+    def create(self, validated_data):
+        if IssueLink.objects.filter(
+            url=validated_data.get("url"), issue_id=validated_data.get("issue_id")
+        ).exists():
+            raise serializers.ValidationError(
+                {"error": "URL already exists for this Issue"}
+            )
+        return IssueLink.objects.create(**validated_data)
+
+    def update(self, instance, validated_data):
+        if (
+            IssueLink.objects.filter(
+                url=validated_data.get("url"), issue_id=instance.issue_id
+            )
+            .exclude(pk=instance.id)
+            .exists()
+        ):
+            raise serializers.ValidationError(
+                {"error": "URL already exists for this Issue"}
+            )
+
+        return super().update(instance, validated_data)
+
+
+class IssueAttachmentSerializer(BaseSerializer):
+    class Meta:
+        model = FileAsset
+        fields = "__all__"
+        read_only_fields = [
+            "id",
+            "workspace",
+            "project",
+            "issue",
+            "updated_by",
+            "updated_at",
+        ]
+
+
+class IssueCommentSerializer(BaseSerializer):
+    is_member = serializers.BooleanField(read_only=True)
+
+    class Meta:
+        model = IssueComment
+        read_only_fields = [
+            "id",
+            "workspace",
+            "project",
+            "issue",
+            "created_by",
+            "updated_by",
+            "created_at",
+            "updated_at",
+        ]
+        exclude = ["comment_stripped", "comment_json"]
+
+    def validate(self, data):
+        try:
+            if data.get("comment_html", None) is not None:
+                parsed = html.fromstring(data["comment_html"])
+                parsed_str = html.tostring(parsed, encoding="unicode")
+                data["comment_html"] = parsed_str
+
+        except Exception:
+            raise serializers.ValidationError("Invalid HTML passed")
+        return data
+
+
+class IssueActivitySerializer(BaseSerializer):
+    class Meta:
+        model = IssueActivity
+        exclude = ["created_by", "updated_by"]
+
+
+class CycleIssueSerializer(BaseSerializer):
+    cycle = CycleSerializer(read_only=True)
+
+    class Meta:
+        fields = ["cycle"]
+
+
+class ModuleIssueSerializer(BaseSerializer):
+    module = ModuleSerializer(read_only=True)
+
+    class Meta:
+        fields = ["module"]
+
+
+class LabelLiteSerializer(BaseSerializer):
+    class Meta:
+        model = Label
+        fields = ["id", "name", "color"]
+
+
+class IssueExpandSerializer(BaseSerializer):
+    cycle = CycleLiteSerializer(source="issue_cycle.cycle", read_only=True)
+    module = ModuleLiteSerializer(source="issue_module.module", read_only=True)
+    labels = LabelLiteSerializer(read_only=True, many=True)
+    assignees = UserLiteSerializer(read_only=True, many=True)
+    state = StateLiteSerializer(read_only=True)
+
+    class Meta:
+        model = Issue
+        fields = "__all__"
+        read_only_fields = [
+            "id",
+            "workspace",
+            "project",
+            "created_by",
+            "updated_by",
+            "created_at",
+            "updated_at",
+        ]

apps/api/plane/api/serializers/module.py

@@ -0,0 +1,179 @@
+# Third party imports
+from rest_framework import serializers
+
+# Module imports
+from .base import BaseSerializer
+from plane.db.models import (
+    User,
+    Module,
+    ModuleLink,
+    ModuleMember,
+    ModuleIssue,
+    ProjectMember,
+)
+
+
+class ModuleSerializer(BaseSerializer):
+    members = serializers.ListField(
+        child=serializers.PrimaryKeyRelatedField(
+            queryset=User.objects.values_list("id", flat=True)
+        ),
+        write_only=True,
+        required=False,
+    )
+    total_issues = serializers.IntegerField(read_only=True)
+    cancelled_issues = serializers.IntegerField(read_only=True)
+    completed_issues = serializers.IntegerField(read_only=True)
+    started_issues = serializers.IntegerField(read_only=True)
+    unstarted_issues = serializers.IntegerField(read_only=True)
+    backlog_issues = serializers.IntegerField(read_only=True)
+
+    class Meta:
+        model = Module
+        fields = "__all__"
+        read_only_fields = [
+            "id",
+            "workspace",
+            "project",
+            "created_by",
+            "updated_by",
+            "created_at",
+            "updated_at",
+            "deleted_at",
+        ]
+
+    def to_representation(self, instance):
+        data = super().to_representation(instance)
+        data["members"] = [str(member.id) for member in instance.members.all()]
+        return data
+
+    def validate(self, data):
+        if (
+            data.get("start_date", None) is not None
+            and data.get("target_date", None) is not None
+            and data.get("start_date", None) > data.get("target_date", None)
+        ):
+            raise serializers.ValidationError("Start date cannot exceed target date")
+
+        if data.get("members", []):
+            data["members"] = ProjectMember.objects.filter(
+                project_id=self.context.get("project_id"), member_id__in=data["members"]
+            ).values_list("member_id", flat=True)
+
+        return data
+
+    def create(self, validated_data):
+        members = validated_data.pop("members", None)
+
+        project_id = self.context["project_id"]
+        workspace_id = self.context["workspace_id"]
+
+        module_name = validated_data.get("name")
+        if module_name:
+            # Lookup for the module name in the module table for that project
+            if Module.objects.filter(name=module_name, project_id=project_id).exists():
+                raise serializers.ValidationError(
+                    {"error": "Module with this name already exists"}
+                )
+
+        module = Module.objects.create(**validated_data, project_id=project_id)
+        if members is not None:
+            ModuleMember.objects.bulk_create(
+                [
+                    ModuleMember(
+                        module=module,
+                        member_id=str(member),
+                        project_id=project_id,
+                        workspace_id=workspace_id,
+                        created_by=module.created_by,
+                        updated_by=module.updated_by,
+                    )
+                    for member in members
+                ],
+                batch_size=10,
+                ignore_conflicts=True,
+            )
+
+        return module
+
+    def update(self, instance, validated_data):
+        members = validated_data.pop("members", None)
+        module_name = validated_data.get("name")
+        if module_name:
+            # Lookup for the module name in the module table for that project
+            if (
+                Module.objects.filter(name=module_name, project=instance.project)
+                .exclude(id=instance.id)
+                .exists()
+            ):
+                raise serializers.ValidationError(
+                    {"error": "Module with this name already exists"}
+                )
+
+        if members is not None:
+            ModuleMember.objects.filter(module=instance).delete()
+            ModuleMember.objects.bulk_create(
+                [
+                    ModuleMember(
+                        module=instance,
+                        member_id=str(member),
+                        project=instance.project,
+                        workspace=instance.project.workspace,
+                        created_by=instance.created_by,
+                        updated_by=instance.updated_by,
+                    )
+                    for member in members
+                ],
+                batch_size=10,
+                ignore_conflicts=True,
+            )
+
+        return super().update(instance, validated_data)
+
+
+class ModuleIssueSerializer(BaseSerializer):
+    sub_issues_count = serializers.IntegerField(read_only=True)
+
+    class Meta:
+        model = ModuleIssue
+        fields = "__all__"
+        read_only_fields = [
+            "workspace",
+            "project",
+            "created_by",
+            "updated_by",
+            "created_at",
+            "updated_at",
+            "module",
+        ]
+
+
+class ModuleLinkSerializer(BaseSerializer):
+    class Meta:
+        model = ModuleLink
+        fields = "__all__"
+        read_only_fields = [
+            "workspace",
+            "project",
+            "created_by",
+            "updated_by",
+            "created_at",
+            "updated_at",
+            "module",
+        ]
+
+    # Validation if url already exists
+    def create(self, validated_data):
+        if ModuleLink.objects.filter(
+            url=validated_data.get("url"), module_id=validated_data.get("module_id")
+        ).exists():
+            raise serializers.ValidationError(
+                {"error": "URL already exists for this Issue"}
+            )
+        return ModuleLink.objects.create(**validated_data)
+
+
+class ModuleLiteSerializer(BaseSerializer):
+    class Meta:
+        model = Module
+        fields = "__all__"

apps/api/plane/api/serializers/project.py

@@ -0,0 +1,98 @@
+# Third party imports
+from rest_framework import serializers
+
+# Module imports
+from plane.db.models import Project, ProjectIdentifier, WorkspaceMember
+
+from .base import BaseSerializer
+
+
+class ProjectSerializer(BaseSerializer):
+    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)
+    cover_image_url = serializers.CharField(read_only=True)
+
+    class Meta:
+        model = Project
+        fields = "__all__"
+        read_only_fields = [
+            "id",
+            "emoji",
+            "workspace",
+            "created_at",
+            "updated_at",
+            "created_by",
+            "updated_by",
+            "deleted_at",
+            "cover_image_url",
+        ]
+
+    def validate(self, data):
+        # Check project lead should be a member of the workspace
+        if (
+            data.get("project_lead", None) is not None
+            and not WorkspaceMember.objects.filter(
+                workspace_id=self.context["workspace_id"],
+                member_id=data.get("project_lead"),
+            ).exists()
+        ):
+            raise serializers.ValidationError(
+                "Project lead should be a user in the workspace"
+            )
+
+        # Check default assignee should be a member of the workspace
+        if (
+            data.get("default_assignee", None) is not None
+            and not WorkspaceMember.objects.filter(
+                workspace_id=self.context["workspace_id"],
+                member_id=data.get("default_assignee"),
+            ).exists()
+        ):
+            raise serializers.ValidationError(
+                "Default assignee should be a user in the workspace"
+            )
+
+        return data
+
+    def create(self, validated_data):
+        identifier = validated_data.get("identifier", "").strip().upper()
+        if identifier == "":
+            raise serializers.ValidationError(detail="Project Identifier is required")
+
+        if ProjectIdentifier.objects.filter(
+            name=identifier, workspace_id=self.context["workspace_id"]
+        ).exists():
+            raise serializers.ValidationError(detail="Project Identifier is taken")
+
+        project = Project.objects.create(
+            **validated_data, workspace_id=self.context["workspace_id"]
+        )
+        _ = ProjectIdentifier.objects.create(
+            name=project.identifier,
+            project=project,
+            workspace_id=self.context["workspace_id"],
+        )
+        return project
+
+
+class ProjectLiteSerializer(BaseSerializer):
+    cover_image_url = serializers.CharField(read_only=True)
+
+    class Meta:
+        model = Project
+        fields = [
+            "id",
+            "identifier",
+            "name",
+            "cover_image",
+            "icon_prop",
+            "emoji",
+            "description",
+            "cover_image_url",
+        ]
+        read_only_fields = fields

apps/api/plane/api/serializers/state.py

@@ -0,0 +1,34 @@
+# Module imports
+from .base import BaseSerializer
+from plane.db.models import State
+
+
+class StateSerializer(BaseSerializer):
+    def validate(self, data):
+        # If the default is being provided then make all other states default False
+        if data.get("default", False):
+            State.objects.filter(project_id=self.context.get("project_id")).update(
+                default=False
+            )
+        return data
+
+    class Meta:
+        model = State
+        fields = "__all__"
+        read_only_fields = [
+            "id",
+            "created_by",
+            "updated_by",
+            "created_at",
+            "updated_at",
+            "workspace",
+            "project",
+            "deleted_at",
+        ]
+
+
+class StateLiteSerializer(BaseSerializer):
+    class Meta:
+        model = State
+        fields = ["id", "name", "color", "group"]
+        read_only_fields = fields

apps/api/plane/api/serializers/user.py

@@ -0,0 +1,20 @@
+# Module imports
+from plane.db.models import User
+
+from .base import BaseSerializer
+
+
+class UserLiteSerializer(BaseSerializer):
+    class Meta:
+        model = User
+        fields = [
+            "id",
+            "first_name",
+            "last_name",
+            "email",
+            "avatar",
+            "avatar_url",
+            "display_name",
+            "email",
+        ]
+        read_only_fields = fields

apps/api/plane/api/serializers/workspace.py

@@ -0,0 +1,12 @@
+# Module imports
+from plane.db.models import Workspace
+from .base import BaseSerializer
+
+
+class WorkspaceLiteSerializer(BaseSerializer):
+    """Lite serializer with only required fields"""
+
+    class Meta:
+        model = Workspace
+        fields = ["name", "slug", "id"]
+        read_only_fields = fields

apps/api/plane/api/urls/__init__.py

@@ -0,0 +1,17 @@
+from .project import urlpatterns as project_patterns
+from .state import urlpatterns as state_patterns
+from .issue import urlpatterns as issue_patterns
+from .cycle import urlpatterns as cycle_patterns
+from .module import urlpatterns as module_patterns
+from .intake import urlpatterns as intake_patterns
+from .member import urlpatterns as member_patterns
+
+urlpatterns = [
+    *project_patterns,
+    *state_patterns,
+    *issue_patterns,
+    *cycle_patterns,
+    *module_patterns,
+    *intake_patterns,
+    *member_patterns,
+]

apps/api/plane/api/urls/cycle.py

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

apps/api/plane/api/urls/intake.py

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

apps/api/plane/api/urls/issue.py

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

apps/api/plane/api/urls/member.py

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

apps/api/plane/api/urls/module.py

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

apps/api/plane/api/urls/project.py

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

apps/api/plane/api/urls/state.py

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

apps/api/plane/api/views/__init__.py

@@ -0,0 +1,30 @@
+from .project import ProjectAPIEndpoint, ProjectArchiveUnarchiveAPIEndpoint
+
+from .state import StateAPIEndpoint
+
+from .issue import (
+    WorkspaceIssueAPIEndpoint,
+    IssueAPIEndpoint,
+    LabelAPIEndpoint,
+    IssueLinkAPIEndpoint,
+    IssueCommentAPIEndpoint,
+    IssueActivityAPIEndpoint,
+    IssueAttachmentEndpoint,
+)
+
+from .cycle import (
+    CycleAPIEndpoint,
+    CycleIssueAPIEndpoint,
+    TransferCycleIssueAPIEndpoint,
+    CycleArchiveUnarchiveAPIEndpoint,
+)
+
+from .module import (
+    ModuleAPIEndpoint,
+    ModuleIssueAPIEndpoint,
+    ModuleArchiveUnarchiveAPIEndpoint,
+)
+
+from .member import ProjectMemberAPIEndpoint
+
+from .intake import IntakeIssueAPIEndpoint

apps/api/plane/api/views/base.py

@@ -0,0 +1,159 @@
+# Python imports
+import zoneinfo
+
+# Django imports
+from django.conf import settings
+from django.core.exceptions import ObjectDoesNotExist, ValidationError
+from django.db import IntegrityError
+from django.urls import resolve
+from django.utils import timezone
+from plane.db.models.api import APIToken
+from rest_framework import status
+from rest_framework.permissions import IsAuthenticated
+from rest_framework.response import Response
+
+# Third party imports
+from rest_framework.views import APIView
+
+# Module imports
+from plane.api.middleware.api_authentication import APIKeyAuthentication
+from plane.api.rate_limit import ApiKeyRateThrottle, ServiceTokenRateThrottle
+from plane.utils.exception_logger import log_exception
+from plane.utils.paginator import BasePaginator
+
+
+class TimezoneMixin:
+    """
+    This enables timezone conversion according
+    to the user set timezone
+    """
+
+    def initial(self, request, *args, **kwargs):
+        super().initial(request, *args, **kwargs)
+        if request.user.is_authenticated:
+            timezone.activate(zoneinfo.ZoneInfo(request.user.user_timezone))
+        else:
+            timezone.deactivate()
+
+
+class BaseAPIView(TimezoneMixin, APIView, BasePaginator):
+    authentication_classes = [APIKeyAuthentication]
+
+    permission_classes = [IsAuthenticated]
+
+    def filter_queryset(self, queryset):
+        for backend in list(self.filter_backends):
+            queryset = backend().filter_queryset(self.request, queryset, self)
+        return queryset
+
+    def get_throttles(self):
+        throttle_classes = []
+        api_key = self.request.headers.get("X-Api-Key")
+
+        if api_key:
+            service_token = APIToken.objects.filter(
+                token=api_key, is_service=True
+            ).first()
+
+            if service_token:
+                throttle_classes.append(ServiceTokenRateThrottle())
+                return throttle_classes
+
+        throttle_classes.append(ApiKeyRateThrottle())
+
+        return throttle_classes
+
+    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):
+                return Response(
+                    {"error": "The requested resource does not exist."},
+                    status=status.HTTP_404_NOT_FOUND,
+                )
+
+            if isinstance(e, KeyError):
+                return Response(
+                    {"error": "The required key does not exist."},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+            log_exception(e)
+            return Response(
+                {"error": "Something went wrong please try again later"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+    def dispatch(self, request, *args, **kwargs):
+        try:
+            response = super().dispatch(request, *args, **kwargs)
+            if settings.DEBUG:
+                from django.db import connection
+
+                print(
+                    f"{request.method} - {request.get_full_path()} of Queries: {len(connection.queries)}"
+                )
+            return response
+        except Exception as exc:
+            response = self.handle_exception(exc)
+            return exc
+
+    def finalize_response(self, request, response, *args, **kwargs):
+        # Call super to get the default response
+        response = super().finalize_response(request, response, *args, **kwargs)
+
+        # Add custom headers if they exist in the request META
+        ratelimit_remaining = request.META.get("X-RateLimit-Remaining")
+        if ratelimit_remaining is not None:
+            response["X-RateLimit-Remaining"] = ratelimit_remaining
+
+        ratelimit_reset = request.META.get("X-RateLimit-Reset")
+        if ratelimit_reset is not None:
+            response["X-RateLimit-Reset"] = ratelimit_reset
+
+        return response
+
+    @property
+    def workspace_slug(self):
+        return self.kwargs.get("slug", None)
+
+    @property
+    def project_id(self):
+        project_id = self.kwargs.get("project_id", None)
+        if project_id:
+            return project_id
+
+        if resolve(self.request.path_info).url_name == "project":
+            return self.kwargs.get("pk", None)
+
+    @property
+    def fields(self):
+        fields = [
+            field for field in self.request.GET.get("fields", "").split(",") if field
+        ]
+        return fields if fields else None
+
+    @property
+    def expand(self):
+        expand = [
+            expand for expand in self.request.GET.get("expand", "").split(",") if expand
+        ]
+        return expand if expand else None

apps/api/plane/api/views/intake.py

@@ -0,0 +1,358 @@
+# Python imports
+import json
+
+# Django imports
+from django.core.serializers.json import DjangoJSONEncoder
+from django.utils import timezone
+from django.db.models import Q, Value, UUIDField
+from django.db.models.functions import Coalesce
+from django.contrib.postgres.aggregates import ArrayAgg
+from django.contrib.postgres.fields import ArrayField
+
+# Third party imports
+from rest_framework import status
+from rest_framework.response import Response
+
+# Module imports
+from plane.api.serializers import IntakeIssueSerializer, IssueSerializer
+from plane.app.permissions import ProjectLitePermission
+from plane.bgtasks.issue_activities_task import issue_activity
+from plane.db.models import Intake, IntakeIssue, Issue, Project, ProjectMember, State
+from plane.utils.host import base_host
+from .base import BaseAPIView
+from plane.db.models.intake import SourceType
+
+
+class IntakeIssueAPIEndpoint(BaseAPIView):
+    """
+    This viewset automatically provides `list`, `create`, `retrieve`,
+    `update` and `destroy` actions related to intake issues.
+
+    """
+
+    permission_classes = [ProjectLitePermission]
+
+    serializer_class = IntakeIssueSerializer
+    model = IntakeIssue
+
+    filterset_fields = ["status"]
+
+    def get_queryset(self):
+        intake = Intake.objects.filter(
+            workspace__slug=self.kwargs.get("slug"),
+            project_id=self.kwargs.get("project_id"),
+        ).first()
+
+        project = Project.objects.get(
+            workspace__slug=self.kwargs.get("slug"), pk=self.kwargs.get("project_id")
+        )
+
+        if intake is None and not project.intake_view:
+            return IntakeIssue.objects.none()
+
+        return (
+            IntakeIssue.objects.filter(
+                Q(snoozed_till__gte=timezone.now()) | Q(snoozed_till__isnull=True),
+                workspace__slug=self.kwargs.get("slug"),
+                project_id=self.kwargs.get("project_id"),
+                intake_id=intake.id,
+            )
+            .select_related("issue", "workspace", "project")
+            .order_by(self.kwargs.get("order_by", "-created_at"))
+        )
+
+    def get(self, request, slug, project_id, issue_id=None):
+        if issue_id:
+            intake_issue_queryset = self.get_queryset().get(issue_id=issue_id)
+            intake_issue_data = IntakeIssueSerializer(
+                intake_issue_queryset, fields=self.fields, expand=self.expand
+            ).data
+            return Response(intake_issue_data, status=status.HTTP_200_OK)
+        issue_queryset = self.get_queryset()
+        return self.paginate(
+            request=request,
+            queryset=(issue_queryset),
+            on_results=lambda intake_issues: IntakeIssueSerializer(
+                intake_issues, many=True, fields=self.fields, expand=self.expand
+            ).data,
+        )
+
+    def post(self, request, slug, project_id):
+        if not request.data.get("issue", {}).get("name", False):
+            return Response(
+                {"error": "Name is required"}, status=status.HTTP_400_BAD_REQUEST
+            )
+
+        intake = Intake.objects.filter(
+            workspace__slug=slug, project_id=project_id
+        ).first()
+
+        project = Project.objects.get(workspace__slug=slug, pk=project_id)
+
+        # Intake view
+        if intake is None and not project.intake_view:
+            return Response(
+                {
+                    "error": "Intake is not enabled for this project enable it through the project's api"
+                },
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # Check for valid priority
+        if request.data.get("issue", {}).get("priority", "none") not in [
+            "low",
+            "medium",
+            "high",
+            "urgent",
+            "none",
+        ]:
+            return Response(
+                {"error": "Invalid priority"}, status=status.HTTP_400_BAD_REQUEST
+            )
+
+        # 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", "none"),
+            project_id=project_id,
+        )
+
+        # create an intake issue
+        intake_issue = IntakeIssue.objects.create(
+            intake_id=intake.id,
+            project_id=project_id,
+            issue=issue,
+            source=SourceType.IN_APP,
+        )
+        # 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()),
+            intake=str(intake_issue.id),
+        )
+
+        serializer = IntakeIssueSerializer(intake_issue)
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+    def patch(self, request, slug, project_id, issue_id):
+        intake = Intake.objects.filter(
+            workspace__slug=slug, project_id=project_id
+        ).first()
+
+        project = Project.objects.get(workspace__slug=slug, pk=project_id)
+
+        # Intake view
+        if intake is None and not project.intake_view:
+            return Response(
+                {
+                    "error": "Intake is not enabled for this project enable it through the project's api"
+                },
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # Get the intake issue
+        intake_issue = IntakeIssue.objects.get(
+            issue_id=issue_id,
+            workspace__slug=slug,
+            project_id=project_id,
+            intake_id=intake.id,
+        )
+
+        # Get the project member
+        project_member = ProjectMember.objects.get(
+            workspace__slug=slug,
+            project_id=project_id,
+            member=request.user,
+            is_active=True,
+        )
+
+        # Only project members admins and created_by users can access this endpoint
+        if project_member.role <= 5 and str(intake_issue.created_by_id) != str(
+            request.user.id
+        ):
+            return Response(
+                {"error": "You cannot edit intake issues"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # Get issue data
+        issue_data = request.data.pop("issue", False)
+
+        if bool(issue_data):
+            issue = Issue.objects.annotate(
+                label_ids=Coalesce(
+                    ArrayAgg(
+                        "labels__id",
+                        distinct=True,
+                        filter=Q(
+                            ~Q(labels__id__isnull=True)
+                            & Q(label_issue__deleted_at__isnull=True)
+                        ),
+                    ),
+                    Value([], output_field=ArrayField(UUIDField())),
+                ),
+                assignee_ids=Coalesce(
+                    ArrayAgg(
+                        "assignees__id",
+                        distinct=True,
+                        filter=Q(
+                            ~Q(assignees__id__isnull=True)
+                            & Q(assignees__member_project__is_active=True)
+                            & Q(issue_assignee__deleted_at__isnull=True)
+                        ),
+                    ),
+                    Value([], output_field=ArrayField(UUIDField())),
+                ),
+            ).get(pk=issue_id, workspace__slug=slug, project_id=project_id)
+            # Only allow guests to edit name and description
+            if project_member.role <= 5:
+                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 = IssueSerializer(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()),
+                        intake=(intake_issue.id),
+                    )
+                issue_serializer.save()
+            else:
+                return Response(
+                    issue_serializer.errors, status=status.HTTP_400_BAD_REQUEST
+                )
+
+        # Only project admins and members can edit intake issue attributes
+        if project_member.role > 15:
+            serializer = IntakeIssueSerializer(
+                intake_issue, data=request.data, partial=True
+            )
+            current_instance = json.dumps(
+                IntakeIssueSerializer(intake_issue).data, cls=DjangoJSONEncoder
+            )
+
+            if serializer.is_valid():
+                serializer.save()
+                # Update the issue state if the issue is rejected or marked as duplicate
+                if serializer.data["status"] in [-1, 2]:
+                    issue = Issue.objects.get(
+                        pk=issue_id, workspace__slug=slug, project_id=project_id
+                    )
+                    state = State.objects.filter(
+                        group="cancelled", workspace__slug=slug, project_id=project_id
+                    ).first()
+                    if state is not None:
+                        issue.state = state
+                        issue.save()
+
+                # Update the issue state if it is accepted
+                if serializer.data["status"] in [1]:
+                    issue = Issue.objects.get(
+                        pk=issue_id, workspace__slug=slug, project_id=project_id
+                    )
+
+                    # Update the issue state only if it is in triage state
+                    if issue.state.is_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()
+
+                # create a activity for status change
+                issue_activity.delay(
+                    type="intake.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=current_instance,
+                    epoch=int(timezone.now().timestamp()),
+                    notification=False,
+                    origin=base_host(request=request, is_app=True),
+                    intake=str(intake_issue.id),
+                )
+
+                return Response(serializer.data, status=status.HTTP_200_OK)
+            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+        else:
+            return Response(
+                IntakeIssueSerializer(intake_issue).data, status=status.HTTP_200_OK
+            )
+
+    def delete(self, request, slug, project_id, issue_id):
+        intake = Intake.objects.filter(
+            workspace__slug=slug, project_id=project_id
+        ).first()
+
+        project = Project.objects.get(workspace__slug=slug, pk=project_id)
+
+        # Intake view
+        if intake is None and not project.intake_view:
+            return Response(
+                {
+                    "error": "Intake is not enabled for this project enable it through the project's api"
+                },
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # Get the intake issue
+        intake_issue = IntakeIssue.objects.get(
+            issue_id=issue_id,
+            workspace__slug=slug,
+            project_id=project_id,
+            intake_id=intake.id,
+        )
+
+        # Check the issue status
+        if intake_issue.status in [-2, -1, 0, 2]:
+            # Delete the issue also
+            issue = Issue.objects.filter(
+                workspace__slug=slug, project_id=project_id, pk=issue_id
+            ).first()
+            if issue.created_by_id != request.user.id and (
+                not ProjectMember.objects.filter(
+                    workspace__slug=slug,
+                    member=request.user,
+                    role=20,
+                    project_id=project_id,
+                    is_active=True,
+                ).exists()
+            ):
+                return Response(
+                    {"error": "Only admin or creator can delete the issue"},
+                    status=status.HTTP_403_FORBIDDEN,
+                )
+            issue.delete()
+
+        intake_issue.delete()
+        return Response(status=status.HTTP_204_NO_CONTENT)

apps/api/plane/api/views/member.py

@@ -0,0 +1,132 @@
+# Python imports
+import uuid
+
+# Django imports
+from django.contrib.auth.hashers import make_password
+from django.core.validators import validate_email
+from django.core.exceptions import ValidationError
+
+# Third Party imports
+from rest_framework.response import Response
+from rest_framework import status
+
+# Module imports
+from .base import BaseAPIView
+from plane.api.serializers import UserLiteSerializer
+from plane.db.models import User, Workspace, Project, WorkspaceMember, ProjectMember
+
+from plane.app.permissions import ProjectMemberPermission
+
+
+# API endpoint to get and insert users inside the workspace
+class ProjectMemberAPIEndpoint(BaseAPIView):
+    permission_classes = [ProjectMemberPermission]
+
+    # Get all the users that are present inside the workspace
+    def get(self, request, slug, project_id):
+        # Check if the workspace exists
+        if not Workspace.objects.filter(slug=slug).exists():
+            return Response(
+                {"error": "Provided workspace does not exist"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # Get the workspace members that are present inside the workspace
+        project_members = ProjectMember.objects.filter(
+            project_id=project_id, workspace__slug=slug
+        ).values_list("member_id", flat=True)
+
+        # Get all the users that are present inside the workspace
+        users = UserLiteSerializer(
+            User.objects.filter(id__in=project_members), many=True
+        ).data
+
+        return Response(users, status=status.HTTP_200_OK)
+
+    # Insert a new user inside the workspace, and assign the user to the project
+    def post(self, request, slug, project_id):
+        # Check if user with email already exists, and send bad request if it's
+        # not present, check for workspace and valid project mandat
+        # ------------------- Validation -------------------
+        if (
+            request.data.get("email") is None
+            or request.data.get("display_name") is None
+        ):
+            return Response(
+                {
+                    "error": "Expected email, display_name, workspace_slug, project_id, one or more of the fields are missing."
+                },
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        email = request.data.get("email")
+
+        try:
+            validate_email(email)
+        except ValidationError:
+            return Response(
+                {"error": "Invalid email provided"}, status=status.HTTP_400_BAD_REQUEST
+            )
+
+        workspace = Workspace.objects.filter(slug=slug).first()
+        project = Project.objects.filter(pk=project_id).first()
+
+        if not all([workspace, project]):
+            return Response(
+                {"error": "Provided workspace or project does not exist"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # Check if user exists
+        user = User.objects.filter(email=email).first()
+        workspace_member = None
+        project_member = None
+
+        if user:
+            # Check if user is part of the workspace
+            workspace_member = WorkspaceMember.objects.filter(
+                workspace=workspace, member=user
+            ).first()
+            if workspace_member:
+                # Check if user is part of the project
+                project_member = ProjectMember.objects.filter(
+                    project=project, member=user
+                ).first()
+                if project_member:
+                    return Response(
+                        {"error": "User is already part of the workspace and project"},
+                        status=status.HTTP_400_BAD_REQUEST,
+                    )
+
+        # If user does not exist, create the user
+        if not user:
+            user = User.objects.create(
+                email=email,
+                display_name=request.data.get("display_name"),
+                first_name=request.data.get("first_name", ""),
+                last_name=request.data.get("last_name", ""),
+                username=uuid.uuid4().hex,
+                password=make_password(uuid.uuid4().hex),
+                is_password_autoset=True,
+                is_active=False,
+            )
+            user.save()
+
+        # Create a workspace member for the user if not already a member
+        if not workspace_member:
+            workspace_member = WorkspaceMember.objects.create(
+                workspace=workspace, member=user, role=request.data.get("role", 5)
+            )
+            workspace_member.save()
+
+        # Create a project member for the user if not already a member
+        if not project_member:
+            project_member = ProjectMember.objects.create(
+                project=project, member=user, role=request.data.get("role", 5)
+            )
+            project_member.save()
+
+        # Serialize the user and return the response
+        user_data = UserLiteSerializer(user).data
+
+        return Response(user_data, status=status.HTTP_201_CREATED)

apps/api/plane/api/views/module.py

@@ -0,0 +1,606 @@
+# Python imports
+import json
+
+# Django imports
+from django.core import serializers
+from django.db.models import Count, F, Func, OuterRef, Prefetch, Q
+from django.utils import timezone
+from django.core.serializers.json import DjangoJSONEncoder
+
+# Third party imports
+from rest_framework import status
+from rest_framework.response import Response
+
+# Module imports
+from plane.api.serializers import (
+    IssueSerializer,
+    ModuleIssueSerializer,
+    ModuleSerializer,
+)
+from plane.app.permissions import ProjectEntityPermission
+from plane.bgtasks.issue_activities_task import issue_activity
+from plane.db.models import (
+    Issue,
+    FileAsset,
+    IssueLink,
+    Module,
+    ModuleIssue,
+    ModuleLink,
+    Project,
+    ProjectMember,
+    UserFavorite,
+)
+
+from .base import BaseAPIView
+from plane.bgtasks.webhook_task import model_activity
+from plane.utils.host import base_host
+
+
+class ModuleAPIEndpoint(BaseAPIView):
+    """
+    This viewset automatically provides `list`, `create`, `retrieve`,
+    `update` and `destroy` actions related to module.
+
+    """
+
+    model = Module
+    permission_classes = [ProjectEntityPermission]
+    serializer_class = ModuleSerializer
+    webhook_event = "module"
+
+    def get_queryset(self):
+        return (
+            Module.objects.filter(project_id=self.kwargs.get("project_id"))
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .select_related("project")
+            .select_related("workspace")
+            .select_related("lead")
+            .prefetch_related("members")
+            .prefetch_related(
+                Prefetch(
+                    "link_module",
+                    queryset=ModuleLink.objects.select_related("module", "created_by"),
+                )
+            )
+            .annotate(
+                total_issues=Count(
+                    "issue_module",
+                    filter=Q(
+                        issue_module__issue__archived_at__isnull=True,
+                        issue_module__issue__is_draft=False,
+                        issue_module__deleted_at__isnull=True,
+                    ),
+                    distinct=True,
+                )
+            )
+            .annotate(
+                completed_issues=Count(
+                    "issue_module__issue__state__group",
+                    filter=Q(
+                        issue_module__issue__state__group="completed",
+                        issue_module__issue__archived_at__isnull=True,
+                        issue_module__issue__is_draft=False,
+                        issue_module__deleted_at__isnull=True,
+                    ),
+                    distinct=True,
+                )
+            )
+            .annotate(
+                cancelled_issues=Count(
+                    "issue_module__issue__state__group",
+                    filter=Q(
+                        issue_module__issue__state__group="cancelled",
+                        issue_module__issue__archived_at__isnull=True,
+                        issue_module__issue__is_draft=False,
+                        issue_module__deleted_at__isnull=True,
+                    ),
+                    distinct=True,
+                )
+            )
+            .annotate(
+                started_issues=Count(
+                    "issue_module__issue__state__group",
+                    filter=Q(
+                        issue_module__issue__state__group="started",
+                        issue_module__issue__archived_at__isnull=True,
+                        issue_module__issue__is_draft=False,
+                        issue_module__deleted_at__isnull=True,
+                    ),
+                    distinct=True,
+                )
+            )
+            .annotate(
+                unstarted_issues=Count(
+                    "issue_module__issue__state__group",
+                    filter=Q(
+                        issue_module__issue__state__group="unstarted",
+                        issue_module__issue__archived_at__isnull=True,
+                        issue_module__issue__is_draft=False,
+                        issue_module__deleted_at__isnull=True,
+                    ),
+                    distinct=True,
+                )
+            )
+            .annotate(
+                backlog_issues=Count(
+                    "issue_module__issue__state__group",
+                    filter=Q(
+                        issue_module__issue__state__group="backlog",
+                        issue_module__issue__archived_at__isnull=True,
+                        issue_module__issue__is_draft=False,
+                        issue_module__deleted_at__isnull=True,
+                    ),
+                    distinct=True,
+                )
+            )
+            .order_by(self.kwargs.get("order_by", "-created_at"))
+        )
+
+    def post(self, request, slug, project_id):
+        project = Project.objects.get(pk=project_id, workspace__slug=slug)
+        serializer = ModuleSerializer(
+            data=request.data,
+            context={"project_id": project_id, "workspace_id": project.workspace_id},
+        )
+        if serializer.is_valid():
+            if (
+                request.data.get("external_id")
+                and request.data.get("external_source")
+                and Module.objects.filter(
+                    project_id=project_id,
+                    workspace__slug=slug,
+                    external_source=request.data.get("external_source"),
+                    external_id=request.data.get("external_id"),
+                ).exists()
+            ):
+                module = Module.objects.filter(
+                    project_id=project_id,
+                    workspace__slug=slug,
+                    external_source=request.data.get("external_source"),
+                    external_id=request.data.get("external_id"),
+                ).first()
+                return Response(
+                    {
+                        "error": "Module with the same external id and external source already exists",
+                        "id": str(module.id),
+                    },
+                    status=status.HTTP_409_CONFLICT,
+                )
+            serializer.save()
+            # Send the model activity
+            model_activity.delay(
+                model_name="module",
+                model_id=str(serializer.data["id"]),
+                requested_data=request.data,
+                current_instance=None,
+                actor_id=request.user.id,
+                slug=slug,
+                origin=base_host(request=request, is_app=True),
+            )
+            module = Module.objects.get(pk=serializer.data["id"])
+            serializer = ModuleSerializer(module)
+            return Response(serializer.data, status=status.HTTP_201_CREATED)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    def patch(self, request, slug, project_id, pk):
+        module = Module.objects.get(pk=pk, project_id=project_id, workspace__slug=slug)
+
+        current_instance = json.dumps(
+            ModuleSerializer(module).data, cls=DjangoJSONEncoder
+        )
+
+        if module.archived_at:
+            return Response(
+                {"error": "Archived module cannot be edited"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+        serializer = ModuleSerializer(
+            module, data=request.data, context={"project_id": project_id}, partial=True
+        )
+        if serializer.is_valid():
+            if (
+                request.data.get("external_id")
+                and (module.external_id != request.data.get("external_id"))
+                and Module.objects.filter(
+                    project_id=project_id,
+                    workspace__slug=slug,
+                    external_source=request.data.get(
+                        "external_source", module.external_source
+                    ),
+                    external_id=request.data.get("external_id"),
+                ).exists()
+            ):
+                return Response(
+                    {
+                        "error": "Module with the same external id and external source already exists",
+                        "id": str(module.id),
+                    },
+                    status=status.HTTP_409_CONFLICT,
+                )
+            serializer.save()
+
+            # Send the model activity
+            model_activity.delay(
+                model_name="module",
+                model_id=str(serializer.data["id"]),
+                requested_data=request.data,
+                current_instance=current_instance,
+                actor_id=request.user.id,
+                slug=slug,
+                origin=base_host(request=request, is_app=True),
+            )
+
+            return Response(serializer.data, status=status.HTTP_200_OK)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    def get(self, request, slug, project_id, pk=None):
+        if pk:
+            queryset = self.get_queryset().filter(archived_at__isnull=True).get(pk=pk)
+            data = ModuleSerializer(
+                queryset, fields=self.fields, expand=self.expand
+            ).data
+            return Response(data, status=status.HTTP_200_OK)
+        return self.paginate(
+            request=request,
+            queryset=(self.get_queryset().filter(archived_at__isnull=True)),
+            on_results=lambda modules: ModuleSerializer(
+                modules, many=True, fields=self.fields, expand=self.expand
+            ).data,
+        )
+
+    def delete(self, request, slug, project_id, pk):
+        module = Module.objects.get(workspace__slug=slug, project_id=project_id, pk=pk)
+        if module.created_by_id != request.user.id and (
+            not ProjectMember.objects.filter(
+                workspace__slug=slug,
+                member=request.user,
+                role=20,
+                project_id=project_id,
+                is_active=True,
+            ).exists()
+        ):
+            return Response(
+                {"error": "Only admin or creator can delete the module"},
+                status=status.HTTP_403_FORBIDDEN,
+            )
+
+        module_issues = list(
+            ModuleIssue.objects.filter(module_id=pk).values_list("issue", flat=True)
+        )
+        issue_activity.delay(
+            type="module.activity.deleted",
+            requested_data=json.dumps(
+                {
+                    "module_id": str(pk),
+                    "module_name": str(module.name),
+                    "issues": [str(issue_id) for issue_id in module_issues],
+                }
+            ),
+            actor_id=str(request.user.id),
+            issue_id=None,
+            project_id=str(project_id),
+            current_instance=json.dumps({"module_name": str(module.name)}),
+            epoch=int(timezone.now().timestamp()),
+            origin=base_host(request=request, is_app=True),
+        )
+        module.delete()
+        # Delete the module issues
+        ModuleIssue.objects.filter(module=pk, project_id=project_id).delete()
+        # Delete the user favorite module
+        UserFavorite.objects.filter(
+            entity_type="module", entity_identifier=pk, project_id=project_id
+        ).delete()
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+class ModuleIssueAPIEndpoint(BaseAPIView):
+    """
+    This viewset automatically provides `list`, `create`, `retrieve`,
+    `update` and `destroy` actions related to module issues.
+
+    """
+
+    serializer_class = ModuleIssueSerializer
+    model = ModuleIssue
+    webhook_event = "module_issue"
+    bulk = True
+
+    permission_classes = [ProjectEntityPermission]
+
+    def get_queryset(self):
+        return (
+            ModuleIssue.objects.annotate(
+                sub_issues_count=Issue.issue_objects.filter(parent=OuterRef("issue"))
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .filter(project_id=self.kwargs.get("project_id"))
+            .filter(module_id=self.kwargs.get("module_id"))
+            .filter(
+                project__project_projectmember__member=self.request.user,
+                project__project_projectmember__is_active=True,
+            )
+            .filter(project__archived_at__isnull=True)
+            .select_related("project")
+            .select_related("workspace")
+            .select_related("module")
+            .select_related("issue", "issue__state", "issue__project")
+            .prefetch_related("issue__assignees", "issue__labels")
+            .prefetch_related("module__members")
+            .order_by(self.kwargs.get("order_by", "-created_at"))
+            .distinct()
+        )
+
+    def get(self, request, slug, project_id, module_id):
+        order_by = request.GET.get("order_by", "created_at")
+        issues = (
+            Issue.issue_objects.filter(
+                issue_module__module_id=module_id, issue_module__deleted_at__isnull=True
+            )
+            .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)
+            .annotate(
+                link_count=IssueLink.objects.filter(issue=OuterRef("id"))
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
+            .annotate(
+                attachment_count=FileAsset.objects.filter(
+                    issue_id=OuterRef("id"),
+                    entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
+                )
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
+        )
+        return self.paginate(
+            request=request,
+            queryset=(issues),
+            on_results=lambda issues: IssueSerializer(
+                issues, many=True, fields=self.fields, expand=self.expand
+            ).data,
+        )
+
+    def post(self, request, slug, project_id, module_id):
+        issues = request.data.get("issues", [])
+        if not len(issues):
+            return Response(
+                {"error": "Issues are required"}, status=status.HTTP_400_BAD_REQUEST
+            )
+        module = Module.objects.get(
+            workspace__slug=slug, project_id=project_id, pk=module_id
+        )
+
+        issues = Issue.objects.filter(
+            workspace__slug=slug, project_id=project_id, pk__in=issues
+        ).values_list("id", flat=True)
+
+        module_issues = list(ModuleIssue.objects.filter(issue_id__in=issues))
+
+        update_module_issue_activity = []
+        records_to_update = []
+        record_to_create = []
+
+        for issue in issues:
+            module_issue = [
+                module_issue
+                for module_issue in module_issues
+                if str(module_issue.issue_id) in issues
+            ]
+
+            if len(module_issue):
+                if module_issue[0].module_id != module_id:
+                    update_module_issue_activity.append(
+                        {
+                            "old_module_id": str(module_issue[0].module_id),
+                            "new_module_id": str(module_id),
+                            "issue_id": str(module_issue[0].issue_id),
+                        }
+                    )
+                    module_issue[0].module_id = module_id
+                    records_to_update.append(module_issue[0])
+            else:
+                record_to_create.append(
+                    ModuleIssue(
+                        module=module,
+                        issue_id=issue,
+                        project_id=project_id,
+                        workspace=module.workspace,
+                        created_by=request.user,
+                        updated_by=request.user,
+                    )
+                )
+
+        ModuleIssue.objects.bulk_create(
+            record_to_create, batch_size=10, ignore_conflicts=True
+        )
+
+        ModuleIssue.objects.bulk_update(records_to_update, ["module"], batch_size=10)
+
+        # Capture Issue Activity
+        issue_activity.delay(
+            type="module.activity.created",
+            requested_data=json.dumps({"modules_list": str(issues)}),
+            actor_id=str(self.request.user.id),
+            issue_id=None,
+            project_id=str(self.kwargs.get("project_id", None)),
+            current_instance=json.dumps(
+                {
+                    "updated_module_issues": update_module_issue_activity,
+                    "created_module_issues": serializers.serialize(
+                        "json", record_to_create
+                    ),
+                }
+            ),
+            epoch=int(timezone.now().timestamp()),
+            origin=base_host(request=request, is_app=True),
+        )
+
+        return Response(
+            ModuleIssueSerializer(self.get_queryset(), many=True).data,
+            status=status.HTTP_200_OK,
+        )
+
+    def delete(self, request, slug, project_id, module_id, issue_id):
+        module_issue = ModuleIssue.objects.get(
+            workspace__slug=slug,
+            project_id=project_id,
+            module_id=module_id,
+            issue_id=issue_id,
+        )
+        module_issue.delete()
+        issue_activity.delay(
+            type="module.activity.deleted",
+            requested_data=json.dumps(
+                {"module_id": str(module_id), "issues": [str(module_issue.issue_id)]}
+            ),
+            actor_id=str(request.user.id),
+            issue_id=str(issue_id),
+            project_id=str(project_id),
+            current_instance=None,
+            epoch=int(timezone.now().timestamp()),
+        )
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+class ModuleArchiveUnarchiveAPIEndpoint(BaseAPIView):
+    permission_classes = [ProjectEntityPermission]
+
+    def get_queryset(self):
+        return (
+            Module.objects.filter(project_id=self.kwargs.get("project_id"))
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .filter(archived_at__isnull=False)
+            .select_related("project")
+            .select_related("workspace")
+            .select_related("lead")
+            .prefetch_related("members")
+            .prefetch_related(
+                Prefetch(
+                    "link_module",
+                    queryset=ModuleLink.objects.select_related("module", "created_by"),
+                )
+            )
+            .annotate(
+                total_issues=Count(
+                    "issue_module",
+                    filter=Q(
+                        issue_module__issue__archived_at__isnull=True,
+                        issue_module__issue__is_draft=False,
+                        issue_module__deleted_at__isnull=True,
+                    ),
+                    distinct=True,
+                )
+            )
+            .annotate(
+                completed_issues=Count(
+                    "issue_module__issue__state__group",
+                    filter=Q(
+                        issue_module__issue__state__group="completed",
+                        issue_module__issue__archived_at__isnull=True,
+                        issue_module__issue__is_draft=False,
+                        issue_module__deleted_at__isnull=True,
+                    ),
+                    distinct=True,
+                )
+            )
+            .annotate(
+                cancelled_issues=Count(
+                    "issue_module__issue__state__group",
+                    filter=Q(
+                        issue_module__issue__state__group="cancelled",
+                        issue_module__issue__archived_at__isnull=True,
+                        issue_module__issue__is_draft=False,
+                        issue_module__deleted_at__isnull=True,
+                    ),
+                    distinct=True,
+                )
+            )
+            .annotate(
+                started_issues=Count(
+                    "issue_module__issue__state__group",
+                    filter=Q(
+                        issue_module__issue__state__group="started",
+                        issue_module__issue__archived_at__isnull=True,
+                        issue_module__issue__is_draft=False,
+                        issue_module__deleted_at__isnull=True,
+                    ),
+                    distinct=True,
+                )
+            )
+            .annotate(
+                unstarted_issues=Count(
+                    "issue_module__issue__state__group",
+                    filter=Q(
+                        issue_module__issue__state__group="unstarted",
+                        issue_module__issue__archived_at__isnull=True,
+                        issue_module__issue__is_draft=False,
+                        issue_module__deleted_at__isnull=True,
+                    ),
+                    distinct=True,
+                )
+            )
+            .annotate(
+                backlog_issues=Count(
+                    "issue_module__issue__state__group",
+                    filter=Q(
+                        issue_module__issue__state__group="backlog",
+                        issue_module__issue__archived_at__isnull=True,
+                        issue_module__issue__is_draft=False,
+                        issue_module__deleted_at__isnull=True,
+                    ),
+                    distinct=True,
+                )
+            )
+            .order_by(self.kwargs.get("order_by", "-created_at"))
+        )
+
+    def get(self, request, slug, project_id, pk):
+        return self.paginate(
+            request=request,
+            queryset=(self.get_queryset()),
+            on_results=lambda modules: ModuleSerializer(
+                modules, many=True, fields=self.fields, expand=self.expand
+            ).data,
+        )
+
+    def post(self, request, slug, project_id, pk):
+        module = Module.objects.get(pk=pk, project_id=project_id, workspace__slug=slug)
+        if module.status not in ["completed", "cancelled"]:
+            return Response(
+                {"error": "Only completed or cancelled modules can be archived"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+        module.archived_at = timezone.now()
+        module.save()
+        UserFavorite.objects.filter(
+            entity_type="module",
+            entity_identifier=pk,
+            project_id=project_id,
+            workspace__slug=slug,
+        ).delete()
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+    def delete(self, request, slug, project_id, pk):
+        module = Module.objects.get(pk=pk, project_id=project_id, workspace__slug=slug)
+        module.archived_at = None
+        module.save()
+        return Response(status=status.HTTP_204_NO_CONTENT)

apps/api/plane/api/views/project.py

@@ -0,0 +1,358 @@
+# Python imports
+import json
+
+# Django imports
+from django.db import IntegrityError
+from django.db.models import Exists, F, Func, OuterRef, Prefetch, Q, Subquery
+from django.utils import timezone
+from django.core.serializers.json import DjangoJSONEncoder
+
+# Third party imports
+from rest_framework import status
+from rest_framework.response import Response
+from rest_framework.serializers import ValidationError
+
+from plane.api.serializers import ProjectSerializer
+from plane.app.permissions import ProjectBasePermission
+
+# Module imports
+from plane.db.models import (
+    Cycle,
+    Intake,
+    IssueUserProperty,
+    Module,
+    Project,
+    DeployBoard,
+    ProjectMember,
+    State,
+    Workspace,
+    UserFavorite,
+)
+from plane.bgtasks.webhook_task import model_activity, webhook_activity
+from .base import BaseAPIView
+from plane.utils.host import base_host
+
+
+class ProjectAPIEndpoint(BaseAPIView):
+    """Project Endpoints to create, update, list, retrieve and delete endpoint"""
+
+    serializer_class = ProjectSerializer
+    model = Project
+    webhook_event = "project"
+
+    permission_classes = [ProjectBasePermission]
+
+    def get_queryset(self):
+        return (
+            Project.objects.filter(workspace__slug=self.kwargs.get("slug"))
+            .filter(
+                Q(
+                    project_projectmember__member=self.request.user,
+                    project_projectmember__is_active=True,
+                )
+                | Q(network=2)
+            )
+            .select_related(
+                "workspace", "workspace__owner", "default_assignee", "project_lead"
+            )
+            .annotate(
+                is_member=Exists(
+                    ProjectMember.objects.filter(
+                        member=self.request.user,
+                        project_id=OuterRef("pk"),
+                        workspace__slug=self.kwargs.get("slug"),
+                        is_active=True,
+                    )
+                )
+            )
+            .annotate(
+                total_members=ProjectMember.objects.filter(
+                    project_id=OuterRef("id"), member__is_bot=False, is_active=True
+                )
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
+            .annotate(
+                total_cycles=Cycle.objects.filter(project_id=OuterRef("id"))
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
+            .annotate(
+                total_modules=Module.objects.filter(project_id=OuterRef("id"))
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
+            .annotate(
+                member_role=ProjectMember.objects.filter(
+                    project_id=OuterRef("pk"),
+                    member_id=self.request.user.id,
+                    is_active=True,
+                ).values("role")
+            )
+            .annotate(
+                is_deployed=Exists(
+                    DeployBoard.objects.filter(
+                        project_id=OuterRef("pk"),
+                        workspace__slug=self.kwargs.get("slug"),
+                    )
+                )
+            )
+            .order_by(self.kwargs.get("order_by", "-created_at"))
+            .distinct()
+        )
+
+    def get(self, request, slug, pk=None):
+        if pk is None:
+            sort_order_query = ProjectMember.objects.filter(
+                member=request.user,
+                project_id=OuterRef("pk"),
+                workspace__slug=self.kwargs.get("slug"),
+                is_active=True,
+            ).values("sort_order")
+            projects = (
+                self.get_queryset()
+                .annotate(sort_order=Subquery(sort_order_query))
+                .prefetch_related(
+                    Prefetch(
+                        "project_projectmember",
+                        queryset=ProjectMember.objects.filter(
+                            workspace__slug=slug, is_active=True
+                        ).select_related("member"),
+                    )
+                )
+                .order_by(request.GET.get("order_by", "sort_order"))
+            )
+            return self.paginate(
+                request=request,
+                queryset=(projects),
+                on_results=lambda projects: ProjectSerializer(
+                    projects, many=True, fields=self.fields, expand=self.expand
+                ).data,
+            )
+        project = self.get_queryset().get(workspace__slug=slug, pk=pk)
+        serializer = ProjectSerializer(project, fields=self.fields, expand=self.expand)
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+    def post(self, request, slug):
+        try:
+            workspace = Workspace.objects.get(slug=slug)
+            serializer = ProjectSerializer(
+                data={**request.data}, context={"workspace_id": workspace.id}
+            )
+            if serializer.is_valid():
+                serializer.save()
+
+                # Add the user as Administrator to the project
+                _ = ProjectMember.objects.create(
+                    project_id=serializer.data["id"], member=request.user, role=20
+                )
+                # Also create the issue property for the user
+                _ = IssueUserProperty.objects.create(
+                    project_id=serializer.data["id"], user=request.user
+                )
+
+                if serializer.data["project_lead"] is not None and str(
+                    serializer.data["project_lead"]
+                ) != str(request.user.id):
+                    ProjectMember.objects.create(
+                        project_id=serializer.data["id"],
+                        member_id=serializer.data["project_lead"],
+                        role=20,
+                    )
+                    # Also create the issue property for the user
+                    IssueUserProperty.objects.create(
+                        project_id=serializer.data["id"],
+                        user_id=serializer.data["project_lead"],
+                    )
+
+                # Default states
+                states = [
+                    {
+                        "name": "Backlog",
+                        "color": "#60646C",
+                        "sequence": 15000,
+                        "group": "backlog",
+                        "default": True,
+                    },
+                    {
+                        "name": "Todo",
+                        "color": "#60646C",
+                        "sequence": 25000,
+                        "group": "unstarted",
+                    },
+                    {
+                        "name": "In Progress",
+                        "color": "#F59E0B",
+                        "sequence": 35000,
+                        "group": "started",
+                    },
+                    {
+                        "name": "Done",
+                        "color": "#46A758",
+                        "sequence": 45000,
+                        "group": "completed",
+                    },
+                    {
+                        "name": "Cancelled",
+                        "color": "#9AA4BC",
+                        "sequence": 55000,
+                        "group": "cancelled",
+                    },
+                ]
+
+                State.objects.bulk_create(
+                    [
+                        State(
+                            name=state["name"],
+                            color=state["color"],
+                            project=serializer.instance,
+                            sequence=state["sequence"],
+                            workspace=serializer.instance.workspace,
+                            group=state["group"],
+                            default=state.get("default", False),
+                            created_by=request.user,
+                        )
+                        for state in states
+                    ]
+                )
+
+                project = self.get_queryset().filter(pk=serializer.data["id"]).first()
+
+                # Model activity
+                model_activity.delay(
+                    model_name="project",
+                    model_id=str(project.id),
+                    requested_data=request.data,
+                    current_instance=None,
+                    actor_id=request.user.id,
+                    slug=slug,
+                    origin=base_host(request=request, is_app=True),
+                )
+
+                serializer = ProjectSerializer(project)
+                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(
+                    {"name": "The project name is already taken"},
+                    status=status.HTTP_409_CONFLICT,
+                )
+        except Workspace.DoesNotExist:
+            return Response(
+                {"error": "Workspace does not exist"}, status=status.HTTP_404_NOT_FOUND
+            )
+        except ValidationError:
+            return Response(
+                {"identifier": "The project identifier is already taken"},
+                status=status.HTTP_409_CONFLICT,
+            )
+
+    def patch(self, request, slug, pk):
+        try:
+            workspace = Workspace.objects.get(slug=slug)
+            project = Project.objects.get(pk=pk)
+            current_instance = json.dumps(
+                ProjectSerializer(project).data, cls=DjangoJSONEncoder
+            )
+
+            intake_view = request.data.get("intake_view", project.intake_view)
+
+            if project.archived_at:
+                return Response(
+                    {"error": "Archived project cannot be updated"},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+            serializer = ProjectSerializer(
+                project,
+                data={**request.data, "intake_view": intake_view},
+                context={"workspace_id": workspace.id},
+                partial=True,
+            )
+
+            if serializer.is_valid():
+                serializer.save()
+                if serializer.data["intake_view"]:
+                    intake = Intake.objects.filter(
+                        project=project, is_default=True
+                    ).first()
+                    if not intake:
+                        Intake.objects.create(
+                            name=f"{project.name} Intake",
+                            project=project,
+                            is_default=True,
+                        )
+
+                project = self.get_queryset().filter(pk=serializer.data["id"]).first()
+
+                model_activity.delay(
+                    model_name="project",
+                    model_id=str(project.id),
+                    requested_data=request.data,
+                    current_instance=current_instance,
+                    actor_id=request.user.id,
+                    slug=slug,
+                    origin=base_host(request=request, is_app=True),
+                )
+
+                serializer = ProjectSerializer(project)
+                return Response(serializer.data, status=status.HTTP_200_OK)
+            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+        except IntegrityError as e:
+            if "already exists" in str(e):
+                return Response(
+                    {"name": "The project name is already taken"},
+                    status=status.HTTP_409_CONFLICT,
+                )
+        except (Project.DoesNotExist, Workspace.DoesNotExist):
+            return Response(
+                {"error": "Project does not exist"}, status=status.HTTP_404_NOT_FOUND
+            )
+        except ValidationError:
+            return Response(
+                {"identifier": "The project identifier is already taken"},
+                status=status.HTTP_409_CONFLICT,
+            )
+
+    def delete(self, request, slug, pk):
+        project = Project.objects.get(pk=pk, workspace__slug=slug)
+        # Delete the user favorite cycle
+        UserFavorite.objects.filter(
+            entity_type="project", entity_identifier=pk, project_id=pk
+        ).delete()
+        project.delete()
+        webhook_activity.delay(
+            event="project",
+            verb="deleted",
+            field=None,
+            old_value=None,
+            new_value=None,
+            actor_id=request.user.id,
+            slug=slug,
+            current_site=base_host(request=request, is_app=True),
+            event_id=project.id,
+            old_identifier=None,
+            new_identifier=None,
+        )
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+class ProjectArchiveUnarchiveAPIEndpoint(BaseAPIView):
+    permission_classes = [ProjectBasePermission]
+
+    def post(self, request, slug, project_id):
+        project = Project.objects.get(pk=project_id, workspace__slug=slug)
+        project.archived_at = timezone.now()
+        project.save()
+        UserFavorite.objects.filter(workspace__slug=slug, project=project_id).delete()
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+    def delete(self, request, slug, project_id):
+        project = Project.objects.get(pk=project_id, workspace__slug=slug)
+        project.archived_at = None
+        project.save()
+        return Response(status=status.HTTP_204_NO_CONTENT)

apps/api/plane/api/views/state.py

@@ -0,0 +1,149 @@
+# Django imports
+from django.db import IntegrityError
+
+# Third party imports
+from rest_framework import status
+from rest_framework.response import Response
+
+from plane.api.serializers import StateSerializer
+from plane.app.permissions import ProjectEntityPermission
+from plane.db.models import Issue, State
+
+# Module imports
+from .base import BaseAPIView
+
+
+class StateAPIEndpoint(BaseAPIView):
+    serializer_class = StateSerializer
+    model = State
+    permission_classes = [ProjectEntityPermission]
+
+    def get_queryset(self):
+        return (
+            State.objects.filter(workspace__slug=self.kwargs.get("slug"))
+            .filter(project_id=self.kwargs.get("project_id"))
+            .filter(
+                project__project_projectmember__member=self.request.user,
+                project__project_projectmember__is_active=True,
+            )
+            .filter(is_triage=False)
+            .filter(project__archived_at__isnull=True)
+            .select_related("project")
+            .select_related("workspace")
+            .distinct()
+        )
+
+    def post(self, request, slug, project_id):
+        try:
+            serializer = StateSerializer(
+                data=request.data, context={"project_id": project_id}
+            )
+            if serializer.is_valid():
+                if (
+                    request.data.get("external_id")
+                    and request.data.get("external_source")
+                    and State.objects.filter(
+                        project_id=project_id,
+                        workspace__slug=slug,
+                        external_source=request.data.get("external_source"),
+                        external_id=request.data.get("external_id"),
+                    ).exists()
+                ):
+                    state = State.objects.filter(
+                        workspace__slug=slug,
+                        project_id=project_id,
+                        external_id=request.data.get("external_id"),
+                        external_source=request.data.get("external_source"),
+                    ).first()
+                    return Response(
+                        {
+                            "error": "State with the same external id and external source already exists",
+                            "id": str(state.id),
+                        },
+                        status=status.HTTP_409_CONFLICT,
+                    )
+
+                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:
+            state = State.objects.filter(
+                workspace__slug=slug,
+                project_id=project_id,
+                name=request.data.get("name"),
+            ).first()
+            return Response(
+                {
+                    "error": "State with the same name already exists in the project",
+                    "id": str(state.id),
+                },
+                status=status.HTTP_409_CONFLICT,
+            )
+
+    def get(self, request, slug, project_id, state_id=None):
+        if state_id:
+            serializer = StateSerializer(
+                self.get_queryset().get(pk=state_id),
+                fields=self.fields,
+                expand=self.expand,
+            )
+            return Response(serializer.data, status=status.HTTP_200_OK)
+        return self.paginate(
+            request=request,
+            queryset=(self.get_queryset()),
+            on_results=lambda states: StateSerializer(
+                states, many=True, fields=self.fields, expand=self.expand
+            ).data,
+        )
+
+    def delete(self, request, slug, project_id, state_id):
+        state = State.objects.get(
+            is_triage=False, pk=state_id, project_id=project_id, workspace__slug=slug
+        )
+
+        if state.default:
+            return Response(
+                {"error": "Default state cannot be deleted"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # Check for any issues in the state
+        issue_exist = Issue.issue_objects.filter(state=state_id).exists()
+
+        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)
+
+    def patch(self, request, slug, project_id, state_id=None):
+        state = State.objects.get(
+            workspace__slug=slug, project_id=project_id, pk=state_id
+        )
+        serializer = StateSerializer(state, data=request.data, partial=True)
+        if serializer.is_valid():
+            if (
+                request.data.get("external_id")
+                and (state.external_id != str(request.data.get("external_id")))
+                and State.objects.filter(
+                    project_id=project_id,
+                    workspace__slug=slug,
+                    external_source=request.data.get(
+                        "external_source", state.external_source
+                    ),
+                    external_id=request.data.get("external_id"),
+                ).exists()
+            ):
+                return Response(
+                    {
+                        "error": "State with the same external id and external source already exists",
+                        "id": str(state.id),
+                    },
+                    status=status.HTTP_409_CONFLICT,
+                )
+            serializer.save()
+            return Response(serializer.data, status=status.HTTP_200_OK)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)