base

plane-src/apps/api/plane/app/__init__.py

@@ -0,0 +1,4 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+

plane-src/apps/api/plane/app/apps.py

@@ -0,0 +1,9 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+from django.apps import AppConfig
+
+
+class AppApiConfig(AppConfig):
+    name = "plane.app"

plane-src/apps/api/plane/app/middleware/__init__.py

@@ -0,0 +1,4 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+

plane-src/apps/api/plane/app/middleware/api_authentication.py

@@ -0,0 +1,51 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+# 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

plane-src/apps/api/plane/app/permissions/__init__.py

@@ -0,0 +1,21 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+from .workspace import (
+    WorkSpaceBasePermission,
+    WorkspaceOwnerPermission,
+    WorkSpaceAdminPermission,
+    WorkspaceEntityPermission,
+    WorkspaceViewerPermission,
+    WorkspaceUserPermission,
+)
+from .project import (
+    ProjectBasePermission,
+    ProjectEntityPermission,
+    ProjectMemberPermission,
+    ProjectLitePermission,
+    ProjectAdminPermission,
+)
+from .base import allow_permission, ROLE
+from .page import ProjectPagePermission

plane-src/apps/api/plane/app/permissions/base.py

@@ -0,0 +1,88 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+from plane.db.models import WorkspaceMember, ProjectMember
+from functools import wraps
+from rest_framework.response import Response
+from rest_framework import status
+
+from enum import Enum
+
+
+class ROLE(Enum):
+    ADMIN = 20
+    MEMBER = 15
+    GUEST = 5
+
+
+def allow_permission(allowed_roles, level="PROJECT", creator=False, model=None):
+    def decorator(view_func):
+        @wraps(view_func)
+        def _wrapped_view(instance, request, *args, **kwargs):
+            # Check for creator if required
+            if creator and model:
+                # check if the user is part of the workspace or not
+                if not WorkspaceMember.objects.filter(
+                    member=request.user,
+                    workspace__slug=kwargs["slug"],
+                    is_active=True,
+                ).exists():
+                    return Response(
+                        {"error": "You don't have the required permissions."},
+                        status=status.HTTP_403_FORBIDDEN,
+                    )
+
+                obj = model.objects.filter(id=kwargs["pk"], created_by=request.user).exists()
+                if obj:
+                    return view_func(instance, request, *args, **kwargs)
+
+            # Convert allowed_roles to their values if they are enum members
+            allowed_role_values = [role.value if isinstance(role, ROLE) else role for role in allowed_roles]
+
+            # Check role permissions
+            if level == "WORKSPACE":
+                if WorkspaceMember.objects.filter(
+                    member=request.user,
+                    workspace__slug=kwargs["slug"],
+                    role__in=allowed_role_values,
+                    is_active=True,
+                ).exists():
+                    return view_func(instance, request, *args, **kwargs)
+            else:
+                is_user_has_allowed_role = ProjectMember.objects.filter(
+                    member=request.user,
+                    workspace__slug=kwargs["slug"],
+                    project_id=kwargs["project_id"],
+                    role__in=allowed_role_values,
+                    is_active=True,
+                ).exists()
+
+                # Return if the user has the allowed role else if they are workspace admin and part of the project regardless of the role # noqa: E501
+                if is_user_has_allowed_role:
+                    return view_func(instance, request, *args, **kwargs)
+                elif (
+                    ProjectMember.objects.filter(
+                        member=request.user,
+                        workspace__slug=kwargs["slug"],
+                        project_id=kwargs["project_id"],
+                        is_active=True,
+                    ).exists()
+                    and WorkspaceMember.objects.filter(
+                        member=request.user,
+                        workspace__slug=kwargs["slug"],
+                        role=ROLE.ADMIN.value,
+                        is_active=True,
+                    ).exists()
+                ):
+                    return view_func(instance, request, *args, **kwargs)
+
+            # Return permission denied if no conditions are met
+            return Response(
+                {"error": "You don't have the required permissions."},
+                status=status.HTTP_403_FORBIDDEN,
+            )
+
+        return _wrapped_view
+
+    return decorator

plane-src/apps/api/plane/app/permissions/page.py

@@ -0,0 +1,125 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+from plane.db.models import ProjectMember, Page
+from plane.app.permissions import ROLE
+
+
+from rest_framework.permissions import BasePermission, SAFE_METHODS
+
+
+# Permission Mappings for workspace members
+ADMIN = ROLE.ADMIN.value
+MEMBER = ROLE.MEMBER.value
+GUEST = ROLE.GUEST.value
+
+
+class ProjectPagePermission(BasePermission):
+    """
+    Custom permission to control access to pages within a workspace
+    based on user roles, page visibility (public/private), and feature flags.
+    """
+
+    def has_permission(self, request, view):
+        """
+        Check basic project-level permissions before checking object-level permissions.
+        """
+        if request.user.is_anonymous:
+            return False
+
+        user_id = request.user.id
+        slug = view.kwargs.get("slug")
+        page_id = view.kwargs.get("page_id")
+        project_id = view.kwargs.get("project_id")
+
+        # Hook for extended validation
+        extended_access, role = self._check_access_and_get_role(request, slug, project_id)
+        if extended_access is False:
+            return False
+
+        if page_id:
+            page = Page.objects.get(id=page_id, workspace__slug=slug)
+
+            # Allow access if the user is the owner of the page
+            if page.owned_by_id == user_id:
+                return True
+
+            # Handle private page access
+            if page.access == Page.PRIVATE_ACCESS:
+                return self._has_private_page_action_access(request, slug, page, project_id)
+
+        # Handle public page access
+        return self._has_public_page_action_access(request, role)
+
+    def _check_project_member_access(self, request, slug, project_id):
+        """
+        Check if the user is a project member.
+        """
+        return (
+            ProjectMember.objects.filter(
+                member=request.user,
+                workspace__slug=slug,
+                is_active=True,
+                project_id=project_id,
+            )
+            .values_list("role", flat=True)
+            .first()
+        )
+
+    def _check_access_and_get_role(self, request, slug, project_id):
+        """
+        Hook for extended access checking
+        Returns: True (allow), False (deny), None (continue with normal flow)
+        """
+        role = self._check_project_member_access(request, slug, project_id)
+        if not role:
+            return False, None
+        return True, role
+
+    def _has_private_page_action_access(self, request, slug, page, project_id):
+        """
+        Check access to private pages. Override for feature flag logic.
+        """
+        # Base implementation: only owner can access private pages
+        return False
+
+    def _check_project_action_access(self, request, role):
+        method = request.method
+
+        # Only admins can create (POST) pages
+        if method == "POST":
+            if role in [ADMIN, MEMBER]:
+                return True
+            return False
+
+        # Safe methods (GET, HEAD, OPTIONS) allowed for all active roles
+        if method in SAFE_METHODS:
+            if role in [ADMIN, MEMBER, GUEST]:
+                return True
+            return False
+
+        # PUT/PATCH: Admins and members can update
+        if method in ["PUT", "PATCH"]:
+            if role in [ADMIN, MEMBER]:
+                return True
+            return False
+
+        # DELETE: Only admins can delete
+        if method == "DELETE":
+            if role in [ADMIN]:
+                return True
+            return False
+
+        # Deny by default
+        return False
+
+    def _has_public_page_action_access(self, request, role):
+        """
+        Check if the user has permission to access a public page
+        and can perform operations on the page.
+        """
+        project_member_exists = self._check_project_action_access(request, role)
+        if not project_member_exists:
+            return False
+        return True

plane-src/apps/api/plane/app/permissions/project.py

@@ -0,0 +1,143 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+# Third Party imports
+from rest_framework.permissions import SAFE_METHODS, BasePermission
+
+# Module import
+from plane.db.models import ProjectMember, WorkspaceMember
+from plane.db.models.project import ROLE
+
+
+class ProjectBasePermission(BasePermission):
+    def has_permission(self, request, view):
+        if request.user.is_anonymous:
+            return False
+
+        ## Safe Methods -> Handle the filtering logic in queryset
+        if request.method in SAFE_METHODS:
+            return WorkspaceMember.objects.filter(
+                workspace__slug=view.workspace_slug, member=request.user, is_active=True
+            ).exists()
+
+        ## Only workspace owners or admins can create the projects
+        if request.method == "POST":
+            return WorkspaceMember.objects.filter(
+                workspace__slug=view.workspace_slug,
+                member=request.user,
+                role__in=[ROLE.ADMIN.value, ROLE.MEMBER.value],
+                is_active=True,
+            ).exists()
+
+        project_member_qs = ProjectMember.objects.filter(
+            workspace__slug=view.workspace_slug,
+            member=request.user,
+            project_id=view.project_id,
+            is_active=True,
+        )
+
+        ## Only project admins or workspace admin who is part of the project can access
+
+        if project_member_qs.filter(role=ROLE.ADMIN.value).exists():
+            return True
+        else:
+            return (
+                project_member_qs.exists()
+                and WorkspaceMember.objects.filter(
+                    member=request.user,
+                    workspace__slug=view.workspace_slug,
+                    role=ROLE.ADMIN.value,
+                    is_active=True,
+                ).exists()
+            )
+
+
+class ProjectMemberPermission(BasePermission):
+    def has_permission(self, request, view):
+        if request.user.is_anonymous:
+            return False
+
+        ## Safe Methods -> Handle the filtering logic in queryset
+        if request.method in SAFE_METHODS:
+            return ProjectMember.objects.filter(
+                workspace__slug=view.workspace_slug, member=request.user, is_active=True
+            ).exists()
+        ## Only workspace owners or admins can create the projects
+        if request.method == "POST":
+            return WorkspaceMember.objects.filter(
+                workspace__slug=view.workspace_slug,
+                member=request.user,
+                role__in=[ROLE.ADMIN.value, ROLE.MEMBER.value],
+                is_active=True,
+            ).exists()
+
+        ## Only Project Admins can update project attributes
+        return ProjectMember.objects.filter(
+            workspace__slug=view.workspace_slug,
+            member=request.user,
+            role__in=[ROLE.ADMIN.value, ROLE.MEMBER.value],
+            project_id=view.project_id,
+            is_active=True,
+        ).exists()
+
+
+class ProjectEntityPermission(BasePermission):
+    def has_permission(self, request, view):
+        if request.user.is_anonymous:
+            return False
+
+        # Handle requests based on project__identifier
+        if hasattr(view, "project_identifier") and view.project_identifier:
+            if request.method in SAFE_METHODS:
+                return ProjectMember.objects.filter(
+                    workspace__slug=view.workspace_slug,
+                    member=request.user,
+                    project__identifier=view.project_identifier,
+                    is_active=True,
+                ).exists()
+
+        ## Safe Methods -> Handle the filtering logic in queryset
+        if request.method in SAFE_METHODS:
+            return ProjectMember.objects.filter(
+                workspace__slug=view.workspace_slug,
+                member=request.user,
+                project_id=view.project_id,
+                is_active=True,
+            ).exists()
+
+        ## Only project members or admins can create and edit the project attributes
+        return ProjectMember.objects.filter(
+            workspace__slug=view.workspace_slug,
+            member=request.user,
+            role__in=[ROLE.ADMIN.value, ROLE.MEMBER.value],
+            project_id=view.project_id,
+            is_active=True,
+        ).exists()
+
+
+class ProjectAdminPermission(BasePermission):
+    def has_permission(self, request, view):
+        if request.user.is_anonymous:
+            return False
+
+        return ProjectMember.objects.filter(
+            workspace__slug=view.workspace_slug,
+            member=request.user,
+            role=ROLE.ADMIN.value,
+            project_id=view.project_id,
+            is_active=True,
+        ).exists()
+
+
+class ProjectLitePermission(BasePermission):
+    def has_permission(self, request, view):
+        if request.user.is_anonymous:
+            return False
+
+        return ProjectMember.objects.filter(
+            workspace__slug=view.workspace_slug,
+            member=request.user,
+            project_id=view.project_id,
+            is_active=True,
+        ).exists()

plane-src/apps/api/plane/app/permissions/workspace.py

@@ -0,0 +1,110 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+# Third Party imports
+from rest_framework.permissions import BasePermission, SAFE_METHODS
+
+# Module imports
+from plane.db.models import WorkspaceMember
+
+
+# Permission Mappings
+Admin = 20
+Member = 15
+Guest = 5
+
+
+# TODO: Move the below logic to python match - python v3.10
+class WorkSpaceBasePermission(BasePermission):
+    def has_permission(self, request, view):
+        # allow anyone to create a workspace
+        if request.user.is_anonymous:
+            return False
+
+        if request.method == "POST":
+            return True
+
+        ## Safe Methods
+        if request.method in SAFE_METHODS:
+            return True
+
+        # allow only admins and owners to update the workspace settings
+        if request.method in ["PUT", "PATCH"]:
+            return WorkspaceMember.objects.filter(
+                member=request.user,
+                workspace__slug=view.workspace_slug,
+                role__in=[Admin, Member],
+                is_active=True,
+            ).exists()
+
+        # allow only owner to delete the workspace
+        if request.method == "DELETE":
+            return WorkspaceMember.objects.filter(
+                member=request.user,
+                workspace__slug=view.workspace_slug,
+                role=Admin,
+                is_active=True,
+            ).exists()
+
+
+class WorkspaceOwnerPermission(BasePermission):
+    def has_permission(self, request, view):
+        if request.user.is_anonymous:
+            return False
+
+        return WorkspaceMember.objects.filter(
+            workspace__slug=view.workspace_slug, member=request.user, role=Admin
+        ).exists()
+
+
+class WorkSpaceAdminPermission(BasePermission):
+    def has_permission(self, request, view):
+        if request.user.is_anonymous:
+            return False
+
+        return WorkspaceMember.objects.filter(
+            member=request.user,
+            workspace__slug=view.workspace_slug,
+            role__in=[Admin, Member],
+            is_active=True,
+        ).exists()
+
+
+class WorkspaceEntityPermission(BasePermission):
+    def has_permission(self, request, view):
+        if request.user.is_anonymous:
+            return False
+
+        ## Safe Methods -> Handle the filtering logic in queryset
+        if request.method in SAFE_METHODS:
+            return WorkspaceMember.objects.filter(
+                workspace__slug=view.workspace_slug, member=request.user, is_active=True
+            ).exists()
+
+        return WorkspaceMember.objects.filter(
+            member=request.user,
+            workspace__slug=view.workspace_slug,
+            role__in=[Admin, Member],
+            is_active=True,
+        ).exists()
+
+
+class WorkspaceViewerPermission(BasePermission):
+    def has_permission(self, request, view):
+        if request.user.is_anonymous:
+            return False
+
+        return WorkspaceMember.objects.filter(
+            member=request.user, workspace__slug=view.workspace_slug, is_active=True
+        ).exists()
+
+
+class WorkspaceUserPermission(BasePermission):
+    def has_permission(self, request, view):
+        if request.user.is_anonymous:
+            return False
+
+        return WorkspaceMember.objects.filter(
+            member=request.user, workspace__slug=view.workspace_slug, is_active=True
+        ).exists()

plane-src/apps/api/plane/app/serializers/__init__.py

@@ -0,0 +1,135 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+from .base import BaseSerializer
+from .user import (
+    UserSerializer,
+    UserLiteSerializer,
+    ChangePasswordSerializer,
+    ResetPasswordSerializer,
+    UserAdminLiteSerializer,
+    UserMeSerializer,
+    UserMeSettingsSerializer,
+    ProfileSerializer,
+    AccountSerializer,
+)
+from .workspace import (
+    WorkSpaceSerializer,
+    WorkSpaceMemberSerializer,
+    WorkSpaceMemberInviteSerializer,
+    WorkspaceLiteSerializer,
+    WorkspaceThemeSerializer,
+    WorkspaceMemberAdminSerializer,
+    WorkspaceMemberMeSerializer,
+    WorkspaceUserPropertiesSerializer,
+    WorkspaceUserLinkSerializer,
+    WorkspaceRecentVisitSerializer,
+    WorkspaceHomePreferenceSerializer,
+    StickySerializer,
+)
+from .project import (
+    ProjectSerializer,
+    ProjectListSerializer,
+    ProjectDetailSerializer,
+    ProjectMemberSerializer,
+    ProjectMemberInviteSerializer,
+    ProjectIdentifierSerializer,
+    ProjectLiteSerializer,
+    ProjectMemberLiteSerializer,
+    DeployBoardSerializer,
+    ProjectMemberAdminSerializer,
+    ProjectPublicMemberSerializer,
+    ProjectMemberRoleSerializer,
+    ProjectMemberPreferenceSerializer,
+)
+from .state import StateSerializer, StateLiteSerializer
+from .view import IssueViewSerializer, ViewIssueListSerializer
+from .cycle import (
+    CycleSerializer,
+    CycleIssueSerializer,
+    CycleWriteSerializer,
+    CycleUserPropertiesSerializer,
+)
+from .asset import FileAssetSerializer
+from .issue import (
+    IssueCreateSerializer,
+    IssueActivitySerializer,
+    IssueCommentSerializer,
+    ProjectUserPropertySerializer,
+    IssueAssigneeSerializer,
+    LabelSerializer,
+    IssueSerializer,
+    IssueFlatSerializer,
+    IssueStateSerializer,
+    IssueLinkSerializer,
+    IssueIntakeSerializer,
+    IssueLiteSerializer,
+    IssueAttachmentSerializer,
+    IssueSubscriberSerializer,
+    IssueReactionSerializer,
+    CommentReactionSerializer,
+    IssueVoteSerializer,
+    IssueRelationSerializer,
+    RelatedIssueSerializer,
+    IssuePublicSerializer,
+    IssueDetailSerializer,
+    IssueReactionLiteSerializer,
+    IssueAttachmentLiteSerializer,
+    IssueLinkLiteSerializer,
+    IssueVersionDetailSerializer,
+    IssueDescriptionVersionDetailSerializer,
+    IssueListDetailSerializer,
+)
+
+from .module import (
+    ModuleDetailSerializer,
+    ModuleWriteSerializer,
+    ModuleSerializer,
+    ModuleIssueSerializer,
+    ModuleLinkSerializer,
+    ModuleUserPropertiesSerializer,
+)
+
+from .api import APITokenSerializer, APITokenReadSerializer
+
+from .importer import ImporterSerializer
+
+from .page import (
+    PageSerializer,
+    PageDetailSerializer,
+    PageVersionSerializer,
+    PageBinaryUpdateSerializer,
+    PageVersionDetailSerializer,
+)
+
+from .estimate import (
+    EstimateSerializer,
+    EstimatePointSerializer,
+    EstimateReadSerializer,
+    WorkspaceEstimateSerializer,
+)
+
+from .intake import (
+    IntakeSerializer,
+    IntakeIssueSerializer,
+    IssueStateIntakeSerializer,
+    IntakeIssueLiteSerializer,
+    IntakeIssueDetailSerializer,
+)
+
+from .analytic import AnalyticViewSerializer
+
+from .notification import NotificationSerializer, UserNotificationPreferenceSerializer
+
+from .exporter import ExporterHistorySerializer
+
+from .webhook import WebhookSerializer, WebhookLogSerializer
+
+from .favorite import UserFavoriteSerializer
+
+from .draft import (
+    DraftIssueCreateSerializer,
+    DraftIssueSerializer,
+    DraftIssueDetailSerializer,
+)

plane-src/apps/api/plane/app/serializers/analytic.py

@@ -0,0 +1,31 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+from .base import BaseSerializer
+from plane.db.models import AnalyticView
+from plane.utils.issue_filters import issue_filters
+
+
+class AnalyticViewSerializer(BaseSerializer):
+    class Meta:
+        model = AnalyticView
+        fields = "__all__"
+        read_only_fields = ["workspace", "query"]
+
+    def create(self, validated_data):
+        query_params = validated_data.get("query_dict", {})
+        if bool(query_params):
+            validated_data["query"] = issue_filters(query_params, "POST")
+        else:
+            validated_data["query"] = {}
+        return AnalyticView.objects.create(**validated_data)
+
+    def update(self, instance, validated_data):
+        query_params = validated_data.get("query_data", {})
+        if bool(query_params):
+            validated_data["query"] = issue_filters(query_params, "POST")
+        else:
+            validated_data["query"] = {}
+        validated_data["query"] = issue_filters(query_params, "PATCH")
+        return super().update(instance, validated_data)

plane-src/apps/api/plane/app/serializers/api.py

@@ -0,0 +1,44 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+from .base import BaseSerializer
+from plane.db.models import APIToken, APIActivityLog
+from rest_framework import serializers
+from django.utils import timezone
+
+
+class APITokenSerializer(BaseSerializer):
+    class Meta:
+        model = APIToken
+        fields = "__all__"
+        read_only_fields = [
+            "token",
+            "expired_at",
+            "created_at",
+            "updated_at",
+            "workspace",
+            "user",
+            "is_active",
+            "last_used",
+            "user_type",
+        ]
+
+
+class APITokenReadSerializer(BaseSerializer):
+    is_active = serializers.SerializerMethodField()
+
+    class Meta:
+        model = APIToken
+        exclude = ("token",)
+
+    def get_is_active(self, obj: APIToken) -> bool:
+        if obj.expired_at is None:
+            return True
+        return timezone.now() < obj.expired_at
+
+
+class APIActivityLogSerializer(BaseSerializer):
+    class Meta:
+        model = APIActivityLog
+        fields = "__all__"

plane-src/apps/api/plane/app/serializers/asset.py

@@ -0,0 +1,13 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+from .base import BaseSerializer
+from plane.db.models import FileAsset
+
+
+class FileAssetSerializer(BaseSerializer):
+    class Meta:
+        model = FileAsset
+        fields = "__all__"
+        read_only_fields = ["created_by", "updated_by", "created_at", "updated_at"]

plane-src/apps/api/plane/app/serializers/base.py

@@ -0,0 +1,201 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+from rest_framework import serializers
+
+
+class BaseSerializer(serializers.ModelSerializer):
+    id = serializers.PrimaryKeyRelatedField(read_only=True)
+
+
+class DynamicBaseSerializer(BaseSerializer):
+    def __init__(self, *args, **kwargs):
+        # If 'fields' is provided in the arguments, remove it and store it separately.
+        # This is done so as not to pass this custom argument up to the superclass.
+        fields = kwargs.pop("fields", [])
+        self.expand = kwargs.pop("expand", []) or []
+        fields = self.expand
+
+        # Call the initialization of the superclass.
+        super().__init__(*args, **kwargs)
+        # If 'fields' was provided, filter the fields of the serializer accordingly.
+        if fields is not None:
+            self.fields = self._filter_fields(fields)
+
+    def _filter_fields(self, fields):
+        """
+        Adjust the serializer's fields based on the provided 'fields' list.
+
+        :param fields: List or dictionary specifying which fields to include in the serializer.
+        :return: The updated fields for the serializer.
+        """
+        # Check each field_name in the provided fields.
+        for field_name in fields:
+            # If the field is a dictionary (indicating nested fields),
+            # loop through its keys and values.
+            if isinstance(field_name, dict):
+                for key, value in field_name.items():
+                    # If the value of this nested field is a list,
+                    # perform a recursive filter on it.
+                    if isinstance(value, list):
+                        self._filter_fields(self.fields[key], value)
+
+        # Create a list to store allowed fields.
+        allowed = []
+        for item in fields:
+            # If the item is a string, it directly represents a field's name.
+            if isinstance(item, str):
+                allowed.append(item)
+            # If the item is a dictionary, it represents a nested field.
+            # Add the key of this dictionary to the allowed list.
+            elif isinstance(item, dict):
+                allowed.append(list(item.keys())[0])
+
+        for field in allowed:
+            if field not in self.fields:
+                from . import (
+                    WorkspaceLiteSerializer,
+                    ProjectLiteSerializer,
+                    UserLiteSerializer,
+                    StateLiteSerializer,
+                    IssueSerializer,
+                    LabelSerializer,
+                    CycleIssueSerializer,
+                    IssueLiteSerializer,
+                    IssueRelationSerializer,
+                    IntakeIssueLiteSerializer,
+                    IssueReactionLiteSerializer,
+                    IssueLinkLiteSerializer,
+                    RelatedIssueSerializer,
+                )
+
+                # 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,
+                    "assignees": UserLiteSerializer,
+                    "labels": LabelSerializer,
+                    "issue_cycle": CycleIssueSerializer,
+                    "parent": IssueLiteSerializer,
+                    "issue_relation": IssueRelationSerializer,
+                    "issue_intake": IntakeIssueLiteSerializer,
+                    "issue_related": RelatedIssueSerializer,
+                    "issue_reactions": IssueReactionLiteSerializer,
+                    "issue_link": IssueLinkLiteSerializer,
+                    "sub_issues": IssueLiteSerializer,
+                }
+
+            if field not in self.fields and field in expansion:
+                self.fields[field] = expansion[field](
+                    many=(
+                        True
+                        if field
+                        in [
+                            "members",
+                            "assignees",
+                            "labels",
+                            "issue_cycle",
+                            "issue_relation",
+                            "issue_intake",
+                            "issue_reactions",
+                            "issue_attachment",
+                            "issue_link",
+                            "sub_issues",
+                            "issue_related",
+                        ]
+                        else False
+                    )
+                )
+
+        return self.fields
+
+    def to_representation(self, instance):
+        response = super().to_representation(instance)
+
+        # Ensure 'expand' is iterable before processing
+        if self.expand:
+            for expand in self.expand:
+                if expand in self.fields:
+                    # Import all the expandable serializers
+                    from . import (
+                        WorkspaceLiteSerializer,
+                        ProjectLiteSerializer,
+                        UserLiteSerializer,
+                        StateLiteSerializer,
+                        IssueSerializer,
+                        LabelSerializer,
+                        CycleIssueSerializer,
+                        IssueRelationSerializer,
+                        IntakeIssueLiteSerializer,
+                        IssueLiteSerializer,
+                        IssueReactionLiteSerializer,
+                        IssueAttachmentLiteSerializer,
+                        IssueLinkLiteSerializer,
+                        RelatedIssueSerializer,
+                    )
+
+                    # 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,
+                        "assignees": UserLiteSerializer,
+                        "labels": LabelSerializer,
+                        "issue_cycle": CycleIssueSerializer,
+                        "parent": IssueLiteSerializer,
+                        "issue_relation": IssueRelationSerializer,
+                        "issue_intake": IntakeIssueLiteSerializer,
+                        "issue_related": RelatedIssueSerializer,
+                        "issue_reactions": IssueReactionLiteSerializer,
+                        "issue_attachment": IssueAttachmentLiteSerializer,
+                        "issue_link": IssueLinkLiteSerializer,
+                        "sub_issues": IssueLiteSerializer,
+                    }
+                    # 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)
+
+            # Check if issue_attachments is in fields or expand
+            if "issue_attachments" in self.fields or "issue_attachments" in self.expand:
+                # Import the model here to avoid circular imports
+                from plane.db.models import FileAsset
+
+                issue_id = getattr(instance, "id", None)
+
+                if issue_id:
+                    # Fetch related issue_attachments
+                    issue_attachments = FileAsset.objects.filter(
+                        issue_id=issue_id,
+                        entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
+                    )
+                    # Serialize issue_attachments and add them to the response
+                    response["issue_attachments"] = IssueAttachmentLiteSerializer(issue_attachments, many=True).data
+                else:
+                    response["issue_attachments"] = []
+
+        return response

plane-src/apps/api/plane/app/serializers/cycle.py

@@ -0,0 +1,106 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+# Third party imports
+from rest_framework import serializers
+
+# Module imports
+from .base import BaseSerializer
+from .issue import IssueStateSerializer
+from plane.db.models import Cycle, CycleIssue, CycleUserProperties
+from plane.utils.timezone_converter import convert_to_utc
+
+
+class CycleWriteSerializer(BaseSerializer):
+    def validate(self, data):
+        if (
+            data.get("start_date", None) is not None
+            and data.get("end_date", None) is not None
+            and data.get("start_date", None) > data.get("end_date", None)
+        ):
+            raise serializers.ValidationError("Start date cannot exceed end date")
+        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", None)
+                or (self.instance and self.instance.project_id)
+                or self.context.get("project_id", None)
+            )
+            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 = ["workspace", "project", "owned_by", "archived_at"]
+
+
+class CycleSerializer(BaseSerializer):
+    # favorite
+    is_favorite = serializers.BooleanField(read_only=True)
+    total_issues = serializers.IntegerField(read_only=True)
+    # state group wise distribution
+    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)
+
+    # active | draft | upcoming | completed
+    status = serializers.CharField(read_only=True)
+
+    class Meta:
+        model = Cycle
+        fields = [
+            # necessary fields
+            "id",
+            "workspace_id",
+            "project_id",
+            # model fields
+            "name",
+            "description",
+            "start_date",
+            "end_date",
+            "owned_by_id",
+            "view_props",
+            "sort_order",
+            "external_source",
+            "external_id",
+            "progress_snapshot",
+            "logo_props",
+            # meta fields
+            "is_favorite",
+            "total_issues",
+            "cancelled_issues",
+            "completed_issues",
+            "started_issues",
+            "unstarted_issues",
+            "backlog_issues",
+            "status",
+        ]
+        read_only_fields = fields
+
+
+class CycleIssueSerializer(BaseSerializer):
+    issue_detail = IssueStateSerializer(read_only=True, source="issue")
+    sub_issues_count = serializers.IntegerField(read_only=True)
+
+    class Meta:
+        model = CycleIssue
+        fields = "__all__"
+        read_only_fields = ["workspace", "project", "cycle"]
+
+
+class CycleUserPropertiesSerializer(BaseSerializer):
+    class Meta:
+        model = CycleUserProperties
+        fields = "__all__"
+        read_only_fields = ["workspace", "project", "cycle", "user"]

plane-src/apps/api/plane/app/serializers/draft.py

@@ -0,0 +1,342 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+# Django imports
+from django.utils import timezone
+
+# Third Party imports
+from rest_framework import serializers
+
+# Module imports
+from .base import BaseSerializer
+from plane.db.models import (
+    User,
+    Issue,
+    Label,
+    State,
+    DraftIssue,
+    DraftIssueAssignee,
+    DraftIssueLabel,
+    DraftIssueCycle,
+    DraftIssueModule,
+    ProjectMember,
+    EstimatePoint,
+)
+from plane.utils.content_validator import (
+    validate_html_content,
+    validate_binary_data,
+)
+from plane.app.permissions import ROLE
+
+
+class DraftIssueCreateSerializer(BaseSerializer):
+    # ids
+    state_id = serializers.PrimaryKeyRelatedField(
+        source="state", queryset=State.objects.all(), required=False, allow_null=True
+    )
+    parent_id = serializers.PrimaryKeyRelatedField(
+        source="parent", queryset=Issue.objects.all(), required=False, allow_null=True
+    )
+    label_ids = serializers.ListField(
+        child=serializers.PrimaryKeyRelatedField(queryset=Label.objects.all()),
+        write_only=True,
+        required=False,
+    )
+    assignee_ids = serializers.ListField(
+        child=serializers.PrimaryKeyRelatedField(queryset=User.objects.all()),
+        write_only=True,
+        required=False,
+    )
+
+    class Meta:
+        model = DraftIssue
+        fields = "__all__"
+        read_only_fields = [
+            "workspace",
+            "created_by",
+            "updated_by",
+            "created_at",
+            "updated_at",
+        ]
+
+    def to_representation(self, instance):
+        data = super().to_representation(instance)
+        assignee_ids = self.initial_data.get("assignee_ids")
+        data["assignee_ids"] = assignee_ids if assignee_ids else []
+        label_ids = self.initial_data.get("label_ids")
+        data["label_ids"] = label_ids if label_ids else []
+        return data
+
+    def validate(self, attrs):
+        if (
+            attrs.get("start_date", None) is not None
+            and attrs.get("target_date", None) is not None
+            and attrs.get("start_date", None) > attrs.get("target_date", None)
+        ):
+            raise serializers.ValidationError("Start date cannot exceed target date")
+
+        # Validate description content for security
+        if "description_html" in attrs and attrs["description_html"]:
+            is_valid, error_msg, sanitized_html = validate_html_content(attrs["description_html"])
+            if not is_valid:
+                raise serializers.ValidationError({"error": "html content is not valid"})
+            # Update the attrs with sanitized HTML if available
+            if sanitized_html is not None:
+                attrs["description_html"] = sanitized_html
+
+        if "description_binary" in attrs and attrs["description_binary"]:
+            is_valid, error_msg = validate_binary_data(attrs["description_binary"])
+            if not is_valid:
+                raise serializers.ValidationError({"description_binary": "Invalid binary data"})
+
+        # Validate assignees are from project
+        if attrs.get("assignee_ids", []):
+            attrs["assignee_ids"] = ProjectMember.objects.filter(
+                project_id=self.context["project_id"],
+                role__gte=ROLE.MEMBER.value,
+                is_active=True,
+                member_id__in=attrs["assignee_ids"],
+            ).values_list("member_id", flat=True)
+
+        # Validate labels are from project
+        if attrs.get("label_ids"):
+            label_ids = [label.id for label in attrs["label_ids"]]
+            attrs["label_ids"] = list(
+                Label.objects.filter(project_id=self.context.get("project_id"), id__in=label_ids).values_list(
+                    "id", flat=True
+                )
+            )
+
+        # # Check state is from the project only else raise validation error
+        if (
+            attrs.get("state")
+            and not State.objects.filter(
+                project_id=self.context.get("project_id"),
+                pk=attrs.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 (
+            attrs.get("parent")
+            and not Issue.objects.filter(
+                project_id=self.context.get("project_id"),
+                pk=attrs.get("parent").id,
+            ).exists()
+        ):
+            raise serializers.ValidationError("Parent is not valid issue_id please pass a valid issue_id")
+
+        if (
+            attrs.get("estimate_point")
+            and not EstimatePoint.objects.filter(
+                project_id=self.context.get("project_id"),
+                pk=attrs.get("estimate_point").id,
+            ).exists()
+        ):
+            raise serializers.ValidationError("Estimate point is not valid please pass a valid estimate_point_id")
+
+        return attrs
+
+    def create(self, validated_data):
+        assignees = validated_data.pop("assignee_ids", None)
+        labels = validated_data.pop("label_ids", None)
+        modules = validated_data.pop("module_ids", None)
+        cycle_id = self.initial_data.get("cycle_id", None)
+        modules = self.initial_data.get("module_ids", None)
+
+        workspace_id = self.context["workspace_id"]
+        project_id = self.context["project_id"]
+
+        # Create Issue
+        issue = DraftIssue.objects.create(**validated_data, workspace_id=workspace_id, project_id=project_id)
+
+        # Issue Audit Users
+        created_by_id = issue.created_by_id
+        updated_by_id = issue.updated_by_id
+
+        if assignees is not None and len(assignees):
+            DraftIssueAssignee.objects.bulk_create(
+                [
+                    DraftIssueAssignee(
+                        assignee_id=assignee_id,
+                        draft_issue=issue,
+                        workspace_id=workspace_id,
+                        project_id=project_id,
+                        created_by_id=created_by_id,
+                        updated_by_id=updated_by_id,
+                    )
+                    for assignee_id in assignees
+                ],
+                batch_size=10,
+            )
+
+        if labels is not None and len(labels):
+            DraftIssueLabel.objects.bulk_create(
+                [
+                    DraftIssueLabel(
+                        label_id=label_id,
+                        draft_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,
+            )
+
+        if cycle_id is not None:
+            DraftIssueCycle.objects.create(
+                cycle_id=cycle_id,
+                draft_issue=issue,
+                project_id=project_id,
+                workspace_id=workspace_id,
+                created_by_id=created_by_id,
+                updated_by_id=updated_by_id,
+            )
+
+        if modules is not None and len(modules):
+            DraftIssueModule.objects.bulk_create(
+                [
+                    DraftIssueModule(
+                        module_id=module_id,
+                        draft_issue=issue,
+                        project_id=project_id,
+                        workspace_id=workspace_id,
+                        created_by_id=created_by_id,
+                        updated_by_id=updated_by_id,
+                    )
+                    for module_id in modules
+                ],
+                batch_size=10,
+            )
+
+        return issue
+
+    def update(self, instance, validated_data):
+        assignees = validated_data.pop("assignee_ids", None)
+        labels = validated_data.pop("label_ids", None)
+        cycle_id = self.context.get("cycle_id", None)
+        modules = self.initial_data.get("module_ids", None)
+
+        # Related models
+        workspace_id = instance.workspace_id
+        project_id = instance.project_id
+
+        created_by_id = instance.created_by_id
+        updated_by_id = instance.updated_by_id
+
+        if assignees is not None:
+            DraftIssueAssignee.objects.filter(draft_issue=instance).delete()
+            DraftIssueAssignee.objects.bulk_create(
+                [
+                    DraftIssueAssignee(
+                        assignee_id=assignee_id,
+                        draft_issue=instance,
+                        workspace_id=workspace_id,
+                        project_id=project_id,
+                        created_by_id=created_by_id,
+                        updated_by_id=updated_by_id,
+                    )
+                    for assignee_id in assignees
+                ],
+                batch_size=10,
+            )
+
+        if labels is not None:
+            DraftIssueLabel.objects.filter(draft_issue=instance).delete()
+            DraftIssueLabel.objects.bulk_create(
+                [
+                    DraftIssueLabel(
+                        label_id=label,
+                        draft_issue=instance,
+                        workspace_id=workspace_id,
+                        project_id=project_id,
+                        created_by_id=created_by_id,
+                        updated_by_id=updated_by_id,
+                    )
+                    for label in labels
+                ],
+                batch_size=10,
+            )
+
+        if cycle_id != "not_provided":
+            DraftIssueCycle.objects.filter(draft_issue=instance).delete()
+            if cycle_id:
+                DraftIssueCycle.objects.create(
+                    cycle_id=cycle_id,
+                    draft_issue=instance,
+                    workspace_id=workspace_id,
+                    project_id=project_id,
+                    created_by_id=created_by_id,
+                    updated_by_id=updated_by_id,
+                )
+
+        if modules is not None:
+            DraftIssueModule.objects.filter(draft_issue=instance).delete()
+            DraftIssueModule.objects.bulk_create(
+                [
+                    DraftIssueModule(
+                        module_id=module_id,
+                        draft_issue=instance,
+                        workspace_id=workspace_id,
+                        project_id=project_id,
+                        created_by_id=created_by_id,
+                        updated_by_id=updated_by_id,
+                    )
+                    for module_id in modules
+                ],
+                batch_size=10,
+            )
+
+        # Time updation occurs even when other related models are updated
+        instance.updated_at = timezone.now()
+        return super().update(instance, validated_data)
+
+
+class DraftIssueSerializer(BaseSerializer):
+    # ids
+    cycle_id = serializers.PrimaryKeyRelatedField(read_only=True)
+    module_ids = serializers.ListField(child=serializers.UUIDField(), required=False)
+
+    # Many to many
+    label_ids = serializers.ListField(child=serializers.UUIDField(), required=False)
+    assignee_ids = serializers.ListField(child=serializers.UUIDField(), required=False)
+
+    class Meta:
+        model = DraftIssue
+        fields = [
+            "id",
+            "name",
+            "state_id",
+            "sort_order",
+            "completed_at",
+            "estimate_point",
+            "priority",
+            "start_date",
+            "target_date",
+            "project_id",
+            "parent_id",
+            "cycle_id",
+            "module_ids",
+            "label_ids",
+            "assignee_ids",
+            "created_at",
+            "updated_at",
+            "created_by",
+            "updated_by",
+            "type_id",
+            "description_html",
+        ]
+        read_only_fields = fields
+
+
+class DraftIssueDetailSerializer(DraftIssueSerializer):
+    description_html = serializers.CharField()
+
+    class Meta(DraftIssueSerializer.Meta):
+        fields = DraftIssueSerializer.Meta.fields + ["description_html"]
+        read_only_fields = fields

plane-src/apps/api/plane/app/serializers/estimate.py

@@ -0,0 +1,50 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+# Module imports
+from .base import BaseSerializer
+
+from plane.db.models import Estimate, EstimatePoint
+
+from rest_framework import serializers
+
+
+class EstimateSerializer(BaseSerializer):
+    class Meta:
+        model = Estimate
+        fields = "__all__"
+        read_only_fields = ["workspace", "project"]
+
+
+class EstimatePointSerializer(BaseSerializer):
+    def validate(self, data):
+        if not data:
+            raise serializers.ValidationError("Estimate points are required")
+        value = data.get("value")
+        if value and len(value) > 20:
+            raise serializers.ValidationError("Value can't be more than 20 characters")
+        return data
+
+    class Meta:
+        model = EstimatePoint
+        fields = "__all__"
+        read_only_fields = ["estimate", "workspace", "project"]
+
+
+class EstimateReadSerializer(BaseSerializer):
+    points = EstimatePointSerializer(read_only=True, many=True)
+
+    class Meta:
+        model = Estimate
+        fields = "__all__"
+        read_only_fields = ["points", "name", "description"]
+
+
+class WorkspaceEstimateSerializer(BaseSerializer):
+    points = EstimatePointSerializer(read_only=True, many=True)
+
+    class Meta:
+        model = Estimate
+        fields = "__all__"
+        read_only_fields = ["points", "name", "description"]

plane-src/apps/api/plane/app/serializers/exporter.py

@@ -0,0 +1,30 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+# Module imports
+from .base import BaseSerializer
+from plane.db.models import ExporterHistory
+from .user import UserLiteSerializer
+
+
+class ExporterHistorySerializer(BaseSerializer):
+    initiated_by_detail = UserLiteSerializer(source="initiated_by", read_only=True)
+
+    class Meta:
+        model = ExporterHistory
+        fields = [
+            "id",
+            "created_at",
+            "updated_at",
+            "project",
+            "provider",
+            "status",
+            "url",
+            "initiated_by",
+            "initiated_by_detail",
+            "token",
+            "created_by",
+            "updated_by",
+        ]
+        read_only_fields = fields

plane-src/apps/api/plane/app/serializers/favorite.py

@@ -0,0 +1,89 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+from rest_framework import serializers
+
+from plane.db.models import UserFavorite, Cycle, Module, Issue, IssueView, Page, Project
+
+
+class ProjectFavoriteLiteSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Project
+        fields = ["id", "name", "logo_props"]
+
+
+class PageFavoriteLiteSerializer(serializers.ModelSerializer):
+    project_id = serializers.SerializerMethodField()
+
+    class Meta:
+        model = Page
+        fields = ["id", "name", "logo_props", "project_id"]
+
+    def get_project_id(self, obj):
+        project = obj.projects.first()  # This gets the first project related to the Page
+        return project.id if project else None
+
+
+class CycleFavoriteLiteSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Cycle
+        fields = ["id", "name", "logo_props", "project_id"]
+
+
+class ModuleFavoriteLiteSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Module
+        fields = ["id", "name", "logo_props", "project_id"]
+
+
+class ViewFavoriteSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = IssueView
+        fields = ["id", "name", "logo_props", "project_id"]
+
+
+def get_entity_model_and_serializer(entity_type):
+    entity_map = {
+        "cycle": (Cycle, CycleFavoriteLiteSerializer),
+        "issue": (Issue, None),
+        "module": (Module, ModuleFavoriteLiteSerializer),
+        "view": (IssueView, ViewFavoriteSerializer),
+        "page": (Page, PageFavoriteLiteSerializer),
+        "project": (Project, ProjectFavoriteLiteSerializer),
+        "folder": (None, None),
+    }
+    return entity_map.get(entity_type, (None, None))
+
+
+class UserFavoriteSerializer(serializers.ModelSerializer):
+    entity_data = serializers.SerializerMethodField()
+
+    class Meta:
+        model = UserFavorite
+        fields = [
+            "id",
+            "entity_type",
+            "entity_identifier",
+            "entity_data",
+            "name",
+            "is_folder",
+            "sequence",
+            "parent",
+            "workspace_id",
+            "project_id",
+        ]
+        read_only_fields = ["workspace", "created_by", "updated_by"]
+
+    def get_entity_data(self, obj):
+        entity_type = obj.entity_type
+        entity_identifier = obj.entity_identifier
+
+        entity_model, entity_serializer = get_entity_model_and_serializer(entity_type)
+        if entity_model and entity_serializer:
+            try:
+                entity = entity_model.objects.get(pk=entity_identifier)
+                return entity_serializer(entity).data
+            except entity_model.DoesNotExist:
+                return None
+        return None

plane-src/apps/api/plane/app/serializers/importer.py

@@ -0,0 +1,20 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+# Module imports
+from .base import BaseSerializer
+from .user import UserLiteSerializer
+from .project import ProjectLiteSerializer
+from .workspace import WorkspaceLiteSerializer
+from plane.db.models import Importer
+
+
+class ImporterSerializer(BaseSerializer):
+    initiated_by_detail = UserLiteSerializer(source="initiated_by", read_only=True)
+    project_detail = ProjectLiteSerializer(source="project", read_only=True)
+    workspace_detail = WorkspaceLiteSerializer(source="workspace", read_only=True)
+
+    class Meta:
+        model = Importer
+        fields = "__all__"

plane-src/apps/api/plane/app/serializers/intake.py

@@ -0,0 +1,137 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+# Third party frameworks
+from rest_framework import serializers
+
+# Module imports
+from .base import BaseSerializer
+from .issue import IssueIntakeSerializer, LabelLiteSerializer, IssueDetailSerializer
+from .project import ProjectLiteSerializer
+from .state import StateLiteSerializer
+from .user import UserLiteSerializer
+from plane.db.models import Intake, IntakeIssue, Issue, StateGroup, State
+
+
+class IntakeSerializer(BaseSerializer):
+    project_detail = ProjectLiteSerializer(source="project", read_only=True)
+    pending_issue_count = serializers.IntegerField(read_only=True)
+
+    class Meta:
+        model = Intake
+        fields = "__all__"
+        read_only_fields = ["project", "workspace"]
+
+
+class IntakeIssueSerializer(BaseSerializer):
+    issue = IssueIntakeSerializer(read_only=True)
+
+    class Meta:
+        model = IntakeIssue
+        fields = [
+            "id",
+            "status",
+            "duplicate_to",
+            "snoozed_till",
+            "source",
+            "issue",
+            "created_by",
+        ]
+        read_only_fields = ["project", "workspace"]
+
+    def validate(self, attrs):
+        """
+        Validate that if status is being changed to accepted (1),
+        the project has a default state to transition to.
+        """
+
+        # Check if status is being updated to accepted
+        if attrs.get("status") == 1:
+            intake_issue = self.instance
+            issue = intake_issue.issue
+
+            # Check if issue is in TRIAGE state
+            if issue.state and issue.state.group == StateGroup.TRIAGE.value:
+                # Verify default state exists before allowing the update
+                default_state = State.objects.filter(
+                    workspace=intake_issue.workspace, project=intake_issue.project, default=True
+                ).first()
+
+                if not default_state:
+                    raise serializers.ValidationError(
+                        {"status": "Cannot accept intake issue: No default state found for the project"}
+                    )
+
+        return attrs
+
+    def update(self, instance, validated_data):
+        # Update the intake issue
+        instance = super().update(instance, validated_data)
+
+        # If status is accepted (1), transition the issue state from TRIAGE to default
+        if validated_data.get("status") == 1:
+            issue = instance.issue
+            if issue.state and issue.state.group == StateGroup.TRIAGE.value:
+                # Get the default project state
+                default_state = State.objects.filter(
+                    workspace=instance.workspace, project=instance.project, default=True
+                ).first()
+                if default_state:
+                    issue.state = default_state
+                    issue.save()
+
+        return instance
+
+    def to_representation(self, instance):
+        # Pass the annotated fields to the Issue instance if they exist
+        if hasattr(instance, "label_ids"):
+            instance.issue.label_ids = instance.label_ids
+        return super().to_representation(instance)
+
+
+class IntakeIssueDetailSerializer(BaseSerializer):
+    issue = IssueDetailSerializer(read_only=True)
+    duplicate_issue_detail = IssueIntakeSerializer(read_only=True, source="duplicate_to")
+
+    class Meta:
+        model = IntakeIssue
+        fields = [
+            "id",
+            "status",
+            "duplicate_to",
+            "snoozed_till",
+            "duplicate_issue_detail",
+            "source",
+            "issue",
+        ]
+        read_only_fields = ["project", "workspace"]
+
+    def to_representation(self, instance):
+        # Pass the annotated fields to the Issue instance if they exist
+        if hasattr(instance, "assignee_ids"):
+            instance.issue.assignee_ids = instance.assignee_ids
+        if hasattr(instance, "label_ids"):
+            instance.issue.label_ids = instance.label_ids
+
+        return super().to_representation(instance)
+
+
+class IntakeIssueLiteSerializer(BaseSerializer):
+    class Meta:
+        model = IntakeIssue
+        fields = ["id", "status", "duplicate_to", "snoozed_till", "source"]
+        read_only_fields = fields
+
+
+class IssueStateIntakeSerializer(BaseSerializer):
+    state_detail = StateLiteSerializer(read_only=True, source="state")
+    project_detail = ProjectLiteSerializer(read_only=True, source="project")
+    label_details = LabelLiteSerializer(read_only=True, source="labels", many=True)
+    assignee_details = UserLiteSerializer(read_only=True, source="assignees", many=True)
+    sub_issues_count = serializers.IntegerField(read_only=True)
+    issue_intake = IntakeIssueLiteSerializer(read_only=True, many=True)
+
+    class Meta:
+        model = Issue
+        fields = "__all__"

plane-src/apps/api/plane/app/serializers/module.py

@@ -0,0 +1,280 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+# Third Party imports
+from rest_framework import serializers
+
+# Module imports
+from .base import BaseSerializer, DynamicBaseSerializer
+from .project import ProjectLiteSerializer
+
+# Django imports
+from django.core.validators import URLValidator
+from django.core.exceptions import ValidationError
+
+from plane.db.models import (
+    User,
+    Module,
+    ModuleMember,
+    ModuleIssue,
+    ModuleLink,
+    ModuleUserProperties,
+)
+
+
+class ModuleWriteSerializer(BaseSerializer):
+    lead_id = serializers.PrimaryKeyRelatedField(
+        source="lead", queryset=User.objects.all(), required=False, allow_null=True
+    )
+    member_ids = serializers.ListField(
+        child=serializers.PrimaryKeyRelatedField(queryset=User.objects.all()),
+        write_only=True,
+        required=False,
+    )
+
+    class Meta:
+        model = Module
+        fields = "__all__"
+        read_only_fields = [
+            "workspace",
+            "project",
+            "created_by",
+            "updated_by",
+            "created_at",
+            "updated_at",
+            "archived_at",
+            "deleted_at",
+        ]
+
+    def to_representation(self, instance):
+        data = super().to_representation(instance)
+        data["member_ids"] = [str(member.id) for member in instance.members.all()]
+        return data
+
+    def validate(self, data):
+        if (
+            data.get("start_date", None) is not None
+            and data.get("target_date", None) is not None
+            and data.get("start_date", None) > data.get("target_date", None)
+        ):
+            raise serializers.ValidationError("Start date cannot exceed target date")
+        return data
+
+    def create(self, validated_data):
+        members = validated_data.pop("member_ids", None)
+        project = self.context["project"]
+
+        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=project).exists():
+                raise serializers.ValidationError({"error": "Module with this name already exists"})
+
+        module = Module.objects.create(**validated_data, project=project)
+        if members is not None:
+            ModuleMember.objects.bulk_create(
+                [
+                    ModuleMember(
+                        module=module,
+                        member=member,
+                        project=project,
+                        workspace=project.workspace,
+                        created_by=module.created_by,
+                        updated_by=module.updated_by,
+                    )
+                    for member in members
+                ],
+                batch_size=10,
+                ignore_conflicts=True,
+            )
+
+        return module
+
+    def update(self, instance, validated_data):
+        members = validated_data.pop("member_ids", 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=member,
+                        project=instance.project,
+                        workspace=instance.project.workspace,
+                        created_by=instance.created_by,
+                        updated_by=instance.updated_by,
+                    )
+                    for member in members
+                ],
+                batch_size=10,
+                ignore_conflicts=True,
+            )
+
+        return super().update(instance, validated_data)
+
+
+class ModuleFlatSerializer(BaseSerializer):
+    class Meta:
+        model = Module
+        fields = "__all__"
+        read_only_fields = [
+            "workspace",
+            "project",
+            "created_by",
+            "updated_by",
+            "created_at",
+            "updated_at",
+        ]
+
+
+class ModuleIssueSerializer(BaseSerializer):
+    module_detail = ModuleFlatSerializer(read_only=True, source="module")
+    issue_detail = ProjectLiteSerializer(read_only=True, source="issue")
+    sub_issues_count = serializers.IntegerField(read_only=True)
+
+    class Meta:
+        model = ModuleIssue
+        fields = "__all__"
+        read_only_fields = [
+            "workspace",
+            "project",
+            "created_by",
+            "updated_by",
+            "created_at",
+            "updated_at",
+            "module",
+        ]
+
+
+class ModuleLinkSerializer(BaseSerializer):
+    class Meta:
+        model = ModuleLink
+        fields = "__all__"
+        read_only_fields = [
+            "workspace",
+            "project",
+            "created_by",
+            "updated_by",
+            "created_at",
+            "updated_at",
+            "module",
+        ]
+
+    def to_internal_value(self, data):
+        # Modify the URL before validation by appending http:// if missing
+        url = data.get("url", "")
+        if url and not url.startswith(("http://", "https://")):
+            data["url"] = "http://" + url
+
+        return super().to_internal_value(data)
+
+    def validate_url(self, value):
+        # Use Django's built-in URLValidator for validation
+        url_validator = URLValidator()
+        try:
+            url_validator(value)
+        except ValidationError:
+            raise serializers.ValidationError({"error": "Invalid URL format."})
+
+        return value
+
+    def create(self, validated_data):
+        validated_data["url"] = self.validate_url(validated_data.get("url"))
+        if ModuleLink.objects.filter(url=validated_data.get("url"), module_id=validated_data.get("module_id")).exists():
+            raise serializers.ValidationError({"error": "URL already exists."})
+        return super().create(validated_data)
+
+    def update(self, instance, validated_data):
+        validated_data["url"] = self.validate_url(validated_data.get("url"))
+        if (
+            ModuleLink.objects.filter(url=validated_data.get("url"), module_id=instance.module_id)
+            .exclude(pk=instance.id)
+            .exists()
+        ):
+            raise serializers.ValidationError({"error": "URL already exists for this Issue"})
+
+        return super().update(instance, validated_data)
+
+
+class ModuleSerializer(DynamicBaseSerializer):
+    member_ids = serializers.ListField(child=serializers.UUIDField(), required=False, allow_null=True)
+    is_favorite = serializers.BooleanField(read_only=True)
+    total_issues = serializers.IntegerField(read_only=True)
+    cancelled_issues = serializers.IntegerField(read_only=True)
+    completed_issues = serializers.IntegerField(read_only=True)
+    started_issues = serializers.IntegerField(read_only=True)
+    unstarted_issues = serializers.IntegerField(read_only=True)
+    backlog_issues = serializers.IntegerField(read_only=True)
+    total_estimate_points = serializers.FloatField(read_only=True)
+    completed_estimate_points = serializers.FloatField(read_only=True)
+
+    class Meta:
+        model = Module
+        fields = [
+            # Required fields
+            "id",
+            "workspace_id",
+            "project_id",
+            # Model fields
+            "name",
+            "description",
+            "description_text",
+            "description_html",
+            "start_date",
+            "target_date",
+            "status",
+            "lead_id",
+            "member_ids",
+            "view_props",
+            "sort_order",
+            "external_source",
+            "external_id",
+            "logo_props",
+            # computed fields
+            "total_estimate_points",
+            "completed_estimate_points",
+            "is_favorite",
+            "total_issues",
+            "cancelled_issues",
+            "completed_issues",
+            "started_issues",
+            "unstarted_issues",
+            "backlog_issues",
+            "created_at",
+            "updated_at",
+            "archived_at",
+        ]
+        read_only_fields = fields
+
+
+class ModuleDetailSerializer(ModuleSerializer):
+    link_module = ModuleLinkSerializer(read_only=True, many=True)
+    sub_issues = serializers.IntegerField(read_only=True)
+    backlog_estimate_points = serializers.FloatField(read_only=True)
+    unstarted_estimate_points = serializers.FloatField(read_only=True)
+    started_estimate_points = serializers.FloatField(read_only=True)
+    cancelled_estimate_points = serializers.FloatField(read_only=True)
+
+    class Meta(ModuleSerializer.Meta):
+        fields = ModuleSerializer.Meta.fields + [
+            "link_module",
+            "sub_issues",
+            "backlog_estimate_points",
+            "unstarted_estimate_points",
+            "started_estimate_points",
+            "cancelled_estimate_points",
+        ]
+
+
+class ModuleUserPropertiesSerializer(BaseSerializer):
+    class Meta:
+        model = ModuleUserProperties
+        fields = "__all__"
+        read_only_fields = ["workspace", "project", "module", "user"]

plane-src/apps/api/plane/app/serializers/notification.py

@@ -0,0 +1,28 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+# Module imports
+from .base import BaseSerializer
+from .user import UserLiteSerializer
+from plane.db.models import Notification, UserNotificationPreference
+
+# Third Party imports
+from rest_framework import serializers
+
+
+class NotificationSerializer(BaseSerializer):
+    triggered_by_details = UserLiteSerializer(read_only=True, source="triggered_by")
+    is_inbox_issue = serializers.BooleanField(read_only=True)
+    is_intake_issue = serializers.BooleanField(read_only=True)
+    is_mentioned_notification = serializers.BooleanField(read_only=True)
+
+    class Meta:
+        model = Notification
+        fields = "__all__"
+
+
+class UserNotificationPreferenceSerializer(BaseSerializer):
+    class Meta:
+        model = UserNotificationPreference
+        fields = "__all__"

plane-src/apps/api/plane/app/serializers/page.py

@@ -0,0 +1,225 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+# Third party imports
+from rest_framework import serializers
+import base64
+
+# Module imports
+from .base import BaseSerializer
+from plane.utils.content_validator import (
+    validate_binary_data,
+    validate_html_content,
+)
+from plane.db.models import (
+    Page,
+    PageLabel,
+    Label,
+    ProjectPage,
+    Project,
+    PageVersion,
+)
+
+
+class PageSerializer(BaseSerializer):
+    is_favorite = serializers.BooleanField(read_only=True)
+    labels = serializers.ListField(
+        child=serializers.PrimaryKeyRelatedField(queryset=Label.objects.all()),
+        write_only=True,
+        required=False,
+    )
+    # Many to many
+    label_ids = serializers.ListField(child=serializers.UUIDField(), required=False)
+    project_ids = serializers.ListField(child=serializers.UUIDField(), required=False)
+
+    class Meta:
+        model = Page
+        fields = [
+            "id",
+            "name",
+            "owned_by",
+            "access",
+            "color",
+            "labels",
+            "parent",
+            "is_favorite",
+            "is_locked",
+            "archived_at",
+            "workspace",
+            "created_at",
+            "updated_at",
+            "created_by",
+            "updated_by",
+            "view_props",
+            "logo_props",
+            "label_ids",
+            "project_ids",
+        ]
+        read_only_fields = ["workspace", "owned_by"]
+
+    def create(self, validated_data):
+        labels = validated_data.pop("labels", None)
+        project_id = self.context["project_id"]
+        owned_by_id = self.context["owned_by_id"]
+        description_json = self.context["description_json"]
+        description_binary = self.context["description_binary"]
+        description_html = self.context["description_html"]
+
+        # Get the workspace id from the project
+        project = Project.objects.get(pk=project_id)
+
+        # Create the page
+        page = Page.objects.create(
+            **validated_data,
+            description_json=description_json,
+            description_binary=description_binary,
+            description_html=description_html,
+            owned_by_id=owned_by_id,
+            workspace_id=project.workspace_id,
+        )
+
+        # Create the project page
+        ProjectPage.objects.create(
+            workspace_id=page.workspace_id,
+            project_id=project_id,
+            page_id=page.id,
+            created_by_id=page.created_by_id,
+            updated_by_id=page.updated_by_id,
+        )
+
+        # Create page labels
+        if labels is not None:
+            PageLabel.objects.bulk_create(
+                [
+                    PageLabel(
+                        label=label,
+                        page=page,
+                        workspace_id=page.workspace_id,
+                        created_by_id=page.created_by_id,
+                        updated_by_id=page.updated_by_id,
+                    )
+                    for label in labels
+                ],
+                batch_size=10,
+            )
+        return page
+
+    def update(self, instance, validated_data):
+        labels = validated_data.pop("labels", None)
+        if labels is not None:
+            PageLabel.objects.filter(page=instance).delete()
+            PageLabel.objects.bulk_create(
+                [
+                    PageLabel(
+                        label=label,
+                        page=instance,
+                        workspace_id=instance.workspace_id,
+                        created_by_id=instance.created_by_id,
+                        updated_by_id=instance.updated_by_id,
+                    )
+                    for label in labels
+                ],
+                batch_size=10,
+            )
+
+        return super().update(instance, validated_data)
+
+
+class PageDetailSerializer(PageSerializer):
+    description_html = serializers.CharField()
+
+    class Meta(PageSerializer.Meta):
+        fields = PageSerializer.Meta.fields + ["description_html"]
+
+
+class PageVersionSerializer(BaseSerializer):
+    class Meta:
+        model = PageVersion
+        fields = [
+            "id",
+            "workspace",
+            "page",
+            "last_saved_at",
+            "owned_by",
+            "created_at",
+            "updated_at",
+            "created_by",
+            "updated_by",
+        ]
+        read_only_fields = ["workspace", "page"]
+
+
+class PageVersionDetailSerializer(BaseSerializer):
+    class Meta:
+        model = PageVersion
+        fields = [
+            "id",
+            "workspace",
+            "page",
+            "last_saved_at",
+            "description_binary",
+            "description_html",
+            "description_json",
+            "owned_by",
+            "created_at",
+            "updated_at",
+            "created_by",
+            "updated_by",
+        ]
+        read_only_fields = ["workspace", "page"]
+
+
+class PageBinaryUpdateSerializer(serializers.Serializer):
+    """Serializer for updating page binary description with validation"""
+
+    description_binary = serializers.CharField(required=False, allow_blank=True)
+    description_html = serializers.CharField(required=False, allow_blank=True)
+    description_json = serializers.JSONField(required=False, allow_null=True)
+
+    def validate_description_binary(self, value):
+        """Validate the base64-encoded binary data"""
+        if not value:
+            return value
+
+        try:
+            # Decode the base64 data
+            binary_data = base64.b64decode(value)
+
+            # Validate the binary data
+            is_valid, error_message = validate_binary_data(binary_data)
+            if not is_valid:
+                raise serializers.ValidationError(f"Invalid binary data: {error_message}")
+
+            return binary_data
+        except Exception as e:
+            if isinstance(e, serializers.ValidationError):
+                raise
+            raise serializers.ValidationError("Failed to decode base64 data")
+
+    def validate_description_html(self, value):
+        """Validate the HTML content"""
+        if not value:
+            return value
+
+        # Use the validation function from utils
+        is_valid, error_message, sanitized_html = validate_html_content(value)
+        if not is_valid:
+            raise serializers.ValidationError(error_message)
+
+        # Return sanitized HTML if available, otherwise return original
+        return sanitized_html if sanitized_html is not None else value
+
+    def update(self, instance, validated_data):
+        """Update the page instance with validated data"""
+        if "description_binary" in validated_data:
+            instance.description_binary = validated_data.get("description_binary")
+
+        if "description_html" in validated_data:
+            instance.description_html = validated_data.get("description_html")
+
+        if "description_json" in validated_data:
+            instance.description_json = validated_data.get("description_json")
+
+        instance.save()
+        return instance

plane-src/apps/api/plane/app/serializers/project.py

@@ -0,0 +1,236 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+# Third party imports
+from rest_framework import serializers
+
+# Python imports
+import re
+
+# Module imports
+from .base import BaseSerializer, DynamicBaseSerializer
+from django.db.models import Max
+from plane.app.serializers.workspace import WorkspaceLiteSerializer
+from plane.app.serializers.user import UserLiteSerializer, UserAdminLiteSerializer
+from plane.db.models import (
+    Project,
+    ProjectMember,
+    ProjectMemberInvite,
+    ProjectIdentifier,
+    DeployBoard,
+    ProjectPublicMember,
+    IssueSequence,
+)
+from plane.utils.content_validator import (
+    validate_html_content,
+)
+
+
+class ProjectSerializer(BaseSerializer):
+    workspace_detail = WorkspaceLiteSerializer(source="workspace", read_only=True)
+    inbox_view = serializers.BooleanField(read_only=True, source="intake_view")
+
+    class Meta:
+        model = Project
+        fields = "__all__"
+        read_only_fields = ["workspace", "deleted_at"]
+
+    def validate_name(self, name):
+        project_id = self.instance.id if self.instance else None
+        workspace_id = self.context["workspace_id"]
+
+        if re.match(Project.FORBIDDEN_IDENTIFIER_CHARS_PATTERN, name):
+            raise serializers.ValidationError(detail="PROJECT_NAME_CANNOT_CONTAIN_SPECIAL_CHARACTERS")
+
+        project = Project.objects.filter(name=name, workspace_id=workspace_id)
+
+        if project_id:
+            project = project.exclude(id=project_id)
+
+        if project.exists():
+            raise serializers.ValidationError(
+                detail="PROJECT_NAME_ALREADY_EXIST",
+            )
+
+        return name
+
+    def validate_identifier(self, identifier):
+        project_id = self.instance.id if self.instance else None
+        workspace_id = self.context["workspace_id"]
+
+        if re.match(Project.FORBIDDEN_IDENTIFIER_CHARS_PATTERN, identifier):
+            raise serializers.ValidationError(detail="PROJECT_IDENTIFIER_CANNOT_CONTAIN_SPECIAL_CHARACTERS")
+
+        project = Project.objects.filter(identifier=identifier, workspace_id=workspace_id)
+
+        if project_id:
+            project = project.exclude(id=project_id)
+
+        if project.exists():
+            raise serializers.ValidationError(
+                detail="PROJECT_IDENTIFIER_ALREADY_EXIST",
+            )
+
+        return identifier
+
+    def validate(self, data):
+        # Validate description content for security
+        if "description_html" in data and data["description_html"]:
+            is_valid, error_msg, sanitized_html = validate_html_content(str(data["description_html"]))
+            # Update the data with sanitized HTML if available
+            if sanitized_html is not None:
+                data["description_html"] = sanitized_html
+
+            if not is_valid:
+                raise serializers.ValidationError({"error": "html content is not valid"})
+
+        return data
+
+    def create(self, validated_data):
+        workspace_id = self.context["workspace_id"]
+
+        project = Project.objects.create(**validated_data, workspace_id=workspace_id)
+
+        ProjectIdentifier.objects.create(name=project.identifier, project=project, workspace_id=workspace_id)
+
+        return project
+
+
+class ProjectLiteSerializer(BaseSerializer):
+    class Meta:
+        model = Project
+        fields = [
+            "id",
+            "identifier",
+            "name",
+            "cover_image",
+            "cover_image_url",
+            "logo_props",
+            "description",
+        ]
+        read_only_fields = fields
+
+
+class ProjectListSerializer(DynamicBaseSerializer):
+    is_favorite = serializers.BooleanField(read_only=True)
+    sort_order = serializers.FloatField(read_only=True)
+    member_role = serializers.IntegerField(read_only=True)
+    anchor = serializers.CharField(read_only=True)
+    members = serializers.SerializerMethodField()
+    cover_image_url = serializers.CharField(read_only=True)
+    inbox_view = serializers.BooleanField(read_only=True, source="intake_view")
+    next_work_item_sequence = serializers.SerializerMethodField()
+
+    def get_members(self, obj):
+        project_members = getattr(obj, "members_list", None)
+        if project_members is not None:
+            # Filter members by the project ID
+            return [member.member_id for member in project_members if member.is_active and not member.member.is_bot]
+        return []
+
+    def get_next_work_item_sequence(self, obj):
+        """Get the next sequence ID that will be assigned to a new issue"""
+        max_sequence = IssueSequence.objects.filter(project_id=obj.id).aggregate(max_seq=Max("sequence"))["max_seq"]
+        return (max_sequence + 1) if max_sequence else 1
+
+    class Meta:
+        model = Project
+        fields = "__all__"
+
+
+class ProjectDetailSerializer(BaseSerializer):
+    # workspace = WorkSpaceSerializer(read_only=True)
+    default_assignee = UserLiteSerializer(read_only=True)
+    project_lead = UserLiteSerializer(read_only=True)
+    is_favorite = serializers.BooleanField(read_only=True)
+    sort_order = serializers.FloatField(read_only=True)
+    member_role = serializers.IntegerField(read_only=True)
+    anchor = serializers.CharField(read_only=True)
+
+    class Meta:
+        model = Project
+        fields = "__all__"
+
+
+class ProjectMemberSerializer(BaseSerializer):
+    workspace = WorkspaceLiteSerializer(read_only=True)
+    project = ProjectLiteSerializer(read_only=True)
+    member = UserLiteSerializer(read_only=True)
+
+    class Meta:
+        model = ProjectMember
+        fields = "__all__"
+
+
+class ProjectMemberPreferenceSerializer(BaseSerializer):
+    class Meta:
+        model = ProjectMember
+        fields = ["preferences", "project_id", "member_id", "workspace_id"]
+
+    def validate_preferences(self, value):
+        preferences = self.instance.preferences
+
+        preferences.update(value)
+        return preferences
+
+
+class ProjectMemberAdminSerializer(BaseSerializer):
+    workspace = WorkspaceLiteSerializer(read_only=True)
+    project = ProjectLiteSerializer(read_only=True)
+    member = UserAdminLiteSerializer(read_only=True)
+
+    class Meta:
+        model = ProjectMember
+        fields = "__all__"
+
+
+class ProjectMemberRoleSerializer(DynamicBaseSerializer):
+    original_role = serializers.IntegerField(source="role", read_only=True)
+
+    class Meta:
+        model = ProjectMember
+        fields = ("id", "role", "member", "project", "original_role", "created_at")
+        read_only_fields = ["original_role", "created_at"]
+
+
+class ProjectMemberInviteSerializer(BaseSerializer):
+    project = ProjectLiteSerializer(read_only=True)
+    workspace = WorkspaceLiteSerializer(read_only=True)
+
+    class Meta:
+        model = ProjectMemberInvite
+        fields = "__all__"
+
+
+class ProjectIdentifierSerializer(BaseSerializer):
+    class Meta:
+        model = ProjectIdentifier
+        fields = "__all__"
+
+
+class ProjectMemberLiteSerializer(BaseSerializer):
+    member = UserLiteSerializer(read_only=True)
+    is_subscribed = serializers.BooleanField(read_only=True)
+
+    class Meta:
+        model = ProjectMember
+        fields = ["member", "id", "is_subscribed"]
+        read_only_fields = fields
+
+
+class DeployBoardSerializer(BaseSerializer):
+    project_details = ProjectLiteSerializer(read_only=True, source="project")
+    workspace_detail = WorkspaceLiteSerializer(read_only=True, source="workspace")
+
+    class Meta:
+        model = DeployBoard
+        fields = "__all__"
+        read_only_fields = ["workspace", "project", "anchor"]
+
+
+class ProjectPublicMemberSerializer(BaseSerializer):
+    class Meta:
+        model = ProjectPublicMember
+        fields = "__all__"
+        read_only_fields = ["workspace", "project", "member"]

plane-src/apps/api/plane/app/serializers/state.py

@@ -0,0 +1,41 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+# Module imports
+from .base import BaseSerializer
+from rest_framework import serializers
+
+from plane.db.models import State, StateGroup
+
+
+class StateSerializer(BaseSerializer):
+    order = serializers.FloatField(required=False)
+
+    class Meta:
+        model = State
+        fields = [
+            "id",
+            "project_id",
+            "workspace_id",
+            "name",
+            "color",
+            "group",
+            "default",
+            "description",
+            "sequence",
+            "order",
+        ]
+        read_only_fields = ["workspace", "project"]
+
+    def validate(self, attrs):
+        if attrs.get("group") == StateGroup.TRIAGE.value:
+            raise serializers.ValidationError("Cannot create triage state")
+        return attrs
+
+
+class StateLiteSerializer(BaseSerializer):
+    class Meta:
+        model = State
+        fields = ["id", "name", "color", "group"]
+        read_only_fields = fields

plane-src/apps/api/plane/app/serializers/user.py

@@ -0,0 +1,212 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+# Third party imports
+from rest_framework import serializers
+
+# Module import
+from plane.db.models import Account, Profile, User, Workspace, WorkspaceMemberInvite
+from plane.utils.url import contains_url
+
+from .base import BaseSerializer
+
+
+class UserSerializer(BaseSerializer):
+    def validate_first_name(self, value):
+        if contains_url(value):
+            raise serializers.ValidationError("First name cannot contain a URL.")
+        return value
+
+    def validate_last_name(self, value):
+        if contains_url(value):
+            raise serializers.ValidationError("Last name cannot contain a URL.")
+        return value
+
+    class Meta:
+        model = User
+        # Exclude password field from the serializer
+        fields = [field.name for field in User._meta.fields if field.name != "password"]
+        # Make all system fields and email read only
+        read_only_fields = [
+            "id",
+            "username",
+            "mobile_number",
+            "email",
+            "token",
+            "created_at",
+            "updated_at",
+            "is_superuser",
+            "is_staff",
+            "is_managed",
+            "last_active",
+            "last_login_time",
+            "last_logout_time",
+            "last_login_ip",
+            "last_logout_ip",
+            "last_login_uagent",
+            "last_location",
+            "last_login_medium",
+            "created_location",
+            "is_bot",
+            "is_password_autoset",
+            "is_email_verified",
+            "is_active",
+            "token_updated_at",
+        ]
+
+        # If the user has already filled first name or last name then he is onboarded
+        def get_is_onboarded(self, obj):
+            return bool(obj.first_name) or bool(obj.last_name)
+
+
+class UserMeSerializer(BaseSerializer):
+    class Meta:
+        model = User
+        fields = [
+            "id",
+            "avatar",
+            "cover_image",
+            "avatar_url",
+            "cover_image_url",
+            "date_joined",
+            "display_name",
+            "email",
+            "first_name",
+            "last_name",
+            "is_active",
+            "is_bot",
+            "is_email_verified",
+            "user_timezone",
+            "username",
+            "is_password_autoset",
+            "is_email_verified",
+            "last_login_medium",
+            "last_login_time",
+        ]
+        read_only_fields = fields
+
+
+class UserMeSettingsSerializer(BaseSerializer):
+    workspace = serializers.SerializerMethodField()
+
+    class Meta:
+        model = User
+        fields = ["id", "email", "workspace"]
+        read_only_fields = fields
+
+    def get_workspace(self, obj):
+        workspace_invites = WorkspaceMemberInvite.objects.filter(email=obj.email).count()
+
+        # profile
+        profile = Profile.objects.get(user=obj)
+        if (
+            profile.last_workspace_id is not None
+            and Workspace.objects.filter(
+                pk=profile.last_workspace_id,
+                workspace_member__member=obj.id,
+                workspace_member__is_active=True,
+            ).exists()
+        ):
+            workspace = Workspace.objects.filter(
+                pk=profile.last_workspace_id,
+                workspace_member__member=obj.id,
+                workspace_member__is_active=True,
+            ).first()
+            logo_asset_url = workspace.logo_asset.asset_url if workspace.logo_asset is not None else ""
+            return {
+                "last_workspace_id": profile.last_workspace_id,
+                "last_workspace_slug": (workspace.slug if workspace is not None else ""),
+                "last_workspace_name": (workspace.name if workspace is not None else ""),
+                "last_workspace_logo": (logo_asset_url),
+                "fallback_workspace_id": profile.last_workspace_id,
+                "fallback_workspace_slug": (workspace.slug if workspace is not None else ""),
+                "invites": workspace_invites,
+            }
+        else:
+            fallback_workspace = (
+                Workspace.objects.filter(workspace_member__member_id=obj.id, workspace_member__is_active=True)
+                .order_by("created_at")
+                .first()
+            )
+            return {
+                "last_workspace_id": None,
+                "last_workspace_slug": None,
+                "fallback_workspace_id": (fallback_workspace.id if fallback_workspace is not None else None),
+                "fallback_workspace_slug": (fallback_workspace.slug if fallback_workspace is not None else None),
+                "invites": workspace_invites,
+            }
+
+
+class UserLiteSerializer(BaseSerializer):
+    class Meta:
+        model = User
+        fields = [
+            "id",
+            "first_name",
+            "last_name",
+            "avatar",
+            "avatar_url",
+            "is_bot",
+            "display_name",
+        ]
+        read_only_fields = ["id", "is_bot"]
+
+
+class UserAdminLiteSerializer(BaseSerializer):
+    class Meta:
+        model = User
+        fields = [
+            "id",
+            "first_name",
+            "last_name",
+            "avatar",
+            "avatar_url",
+            "is_bot",
+            "display_name",
+            "email",
+            "last_login_medium",
+        ]
+        read_only_fields = ["id", "is_bot"]
+
+
+class ChangePasswordSerializer(serializers.Serializer):
+    model = User
+
+    """
+    Serializer for password change endpoint.
+    """
+    old_password = serializers.CharField(required=True)
+    new_password = serializers.CharField(required=True, min_length=8)
+    confirm_password = serializers.CharField(required=True, min_length=8)
+
+    def validate(self, data):
+        if data.get("old_password") == data.get("new_password"):
+            raise serializers.ValidationError({"error": "New password cannot be same as old password."})
+
+        if data.get("new_password") != data.get("confirm_password"):
+            raise serializers.ValidationError({"error": "Confirm password should be same as the new password."})
+
+        return data
+
+
+class ResetPasswordSerializer(serializers.Serializer):
+    """
+    Serializer for password change endpoint.
+    """
+
+    new_password = serializers.CharField(required=True, min_length=8)
+
+
+class ProfileSerializer(BaseSerializer):
+    class Meta:
+        model = Profile
+        fields = "__all__"
+        read_only_fields = ["user"]
+
+
+class AccountSerializer(BaseSerializer):
+    class Meta:
+        model = Account
+        fields = "__all__"
+        read_only_fields = ["user"]

plane-src/apps/api/plane/app/serializers/view.py

@@ -0,0 +1,86 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+# Third party imports
+from rest_framework import serializers
+
+# Module imports
+from .base import DynamicBaseSerializer
+from plane.db.models import IssueView
+from plane.utils.issue_filters import issue_filters
+
+
+class ViewIssueListSerializer(serializers.Serializer):
+    def get_assignee_ids(self, instance):
+        return [assignee.assignee_id for assignee in instance.issue_assignee.all()]
+
+    def get_label_ids(self, instance):
+        return [label.label_id for label in instance.label_issue.all()]
+
+    def get_module_ids(self, instance):
+        return [module.module_id for module in instance.issue_module.all()]
+
+    def to_representation(self, instance):
+        data = {
+            "id": instance.id,
+            "name": instance.name,
+            "state_id": instance.state_id,
+            "sort_order": instance.sort_order,
+            "completed_at": instance.completed_at,
+            "estimate_point": instance.estimate_point_id,
+            "priority": instance.priority,
+            "start_date": instance.start_date,
+            "target_date": instance.target_date,
+            "sequence_id": instance.sequence_id,
+            "project_id": instance.project_id,
+            "parent_id": instance.parent_id,
+            "cycle_id": instance.cycle_id,
+            "sub_issues_count": instance.sub_issues_count,
+            "created_at": instance.created_at,
+            "updated_at": instance.updated_at,
+            "created_by": instance.created_by_id,
+            "updated_by": instance.updated_by_id,
+            "attachment_count": instance.attachment_count,
+            "link_count": instance.link_count,
+            "is_draft": instance.is_draft,
+            "archived_at": instance.archived_at,
+            "state__group": instance.state.group if instance.state else None,
+            "assignee_ids": self.get_assignee_ids(instance),
+            "label_ids": self.get_label_ids(instance),
+            "module_ids": self.get_module_ids(instance),
+        }
+        return data
+
+
+class IssueViewSerializer(DynamicBaseSerializer):
+    is_favorite = serializers.BooleanField(read_only=True)
+
+    class Meta:
+        model = IssueView
+        fields = "__all__"
+        read_only_fields = [
+            "workspace",
+            "project",
+            "query",
+            "owned_by",
+            "access",
+            "is_locked",
+        ]
+
+    def create(self, validated_data):
+        query_params = validated_data.get("filters", {})
+        if bool(query_params):
+            validated_data["query"] = issue_filters(query_params, "POST")
+        else:
+            validated_data["query"] = {}
+        return IssueView.objects.create(**validated_data)
+
+    def update(self, instance, validated_data):
+        query_params = validated_data.get("filters", {})
+        if bool(query_params):
+            validated_data["query"] = issue_filters(query_params, "POST")
+        else:
+            validated_data["query"] = {}
+        validated_data["query"] = issue_filters(query_params, "PATCH")
+        return super().update(instance, validated_data)

plane-src/apps/api/plane/app/serializers/webhook.py

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

plane-src/apps/api/plane/app/serializers/workspace.py

@@ -0,0 +1,333 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+# Third party imports
+from rest_framework import serializers
+
+# Module imports
+from .base import BaseSerializer, DynamicBaseSerializer
+from .user import UserLiteSerializer, UserAdminLiteSerializer
+
+
+from plane.db.models import (
+    Workspace,
+    WorkspaceMember,
+    WorkspaceMemberInvite,
+    WorkspaceTheme,
+    WorkspaceUserProperties,
+    WorkspaceUserLink,
+    UserRecentVisit,
+    Issue,
+    Page,
+    Project,
+    ProjectMember,
+    WorkspaceHomePreference,
+    Sticky,
+    WorkspaceUserPreference,
+)
+from plane.utils.constants import RESTRICTED_WORKSPACE_SLUGS
+from plane.utils.url import contains_url
+from plane.utils.content_validator import (
+    validate_html_content,
+    validate_binary_data,
+)
+
+# Django imports
+from django.core.validators import URLValidator
+from django.core.exceptions import ValidationError
+import re
+
+
+class WorkSpaceSerializer(DynamicBaseSerializer):
+    total_members = serializers.IntegerField(read_only=True)
+    logo_url = serializers.CharField(read_only=True)
+    role = serializers.IntegerField(read_only=True)
+
+    def validate_name(self, value):
+        # Check if the name contains a URL
+        if contains_url(value):
+            raise serializers.ValidationError("Name must not contain URLs")
+        return value
+
+    def validate_slug(self, value):
+        # Check if the slug is restricted
+        if value in RESTRICTED_WORKSPACE_SLUGS:
+            raise serializers.ValidationError("Slug is not valid")
+        # Slug should only contain alphanumeric characters, hyphens, and underscores
+        if not re.match(r"^[a-zA-Z0-9_-]+$", value):
+            raise serializers.ValidationError(
+                "Slug can only contain letters, numbers, hyphens (-), and underscores (_)"
+            )
+        return value
+
+    class Meta:
+        model = Workspace
+        fields = "__all__"
+        read_only_fields = [
+            "id",
+            "created_by",
+            "updated_by",
+            "created_at",
+            "updated_at",
+            "owner",
+            "logo_url",
+        ]
+
+
+class WorkspaceLiteSerializer(BaseSerializer):
+    class Meta:
+        model = Workspace
+        fields = ["name", "slug", "id", "logo_url"]
+        read_only_fields = fields
+
+
+class WorkSpaceMemberSerializer(DynamicBaseSerializer):
+    member = UserLiteSerializer(read_only=True)
+
+    class Meta:
+        model = WorkspaceMember
+        fields = "__all__"
+
+
+class WorkspaceMemberMeSerializer(BaseSerializer):
+    draft_issue_count = serializers.IntegerField(read_only=True)
+
+    class Meta:
+        model = WorkspaceMember
+        fields = "__all__"
+
+
+class WorkspaceMemberAdminSerializer(DynamicBaseSerializer):
+    member = UserAdminLiteSerializer(read_only=True)
+
+    class Meta:
+        model = WorkspaceMember
+        fields = "__all__"
+
+
+class WorkSpaceMemberInviteSerializer(BaseSerializer):
+    workspace = WorkspaceLiteSerializer(read_only=True)
+    invite_link = serializers.SerializerMethodField()
+
+    def get_invite_link(self, obj):
+        return f"/workspace-invitations/?invitation_id={obj.id}&slug={obj.workspace.slug}&token={obj.token}"
+
+    class Meta:
+        model = WorkspaceMemberInvite
+        fields = "__all__"
+        read_only_fields = [
+            "id",
+            "email",
+            "token",
+            "workspace",
+            "message",
+            "responded_at",
+            "created_at",
+            "updated_at",
+            "invite_link",
+        ]
+
+
+class WorkspaceThemeSerializer(BaseSerializer):
+    class Meta:
+        model = WorkspaceTheme
+        fields = "__all__"
+        read_only_fields = ["workspace", "actor"]
+
+
+class WorkspaceUserPropertiesSerializer(BaseSerializer):
+    class Meta:
+        model = WorkspaceUserProperties
+        fields = "__all__"
+        read_only_fields = ["workspace", "user"]
+
+
+class WorkspaceUserLinkSerializer(BaseSerializer):
+    class Meta:
+        model = WorkspaceUserLink
+        fields = "__all__"
+        read_only_fields = ["workspace", "owner"]
+
+    def to_internal_value(self, data):
+        url = data.get("url", "")
+        if url and not url.startswith(("http://", "https://")):
+            data["url"] = "http://" + url
+
+        return super().to_internal_value(data)
+
+    def validate_url(self, value):
+        url_validator = URLValidator()
+        try:
+            url_validator(value)
+        except ValidationError:
+            raise serializers.ValidationError({"error": "Invalid URL format."})
+
+        return value
+
+    def create(self, validated_data):
+        # Filtering the WorkspaceUserLink with the given url to check if the link already exists.
+
+        url = validated_data.get("url")
+
+        workspace_user_link = WorkspaceUserLink.objects.filter(
+            url=url,
+            workspace_id=validated_data.get("workspace_id"),
+            owner_id=validated_data.get("owner_id"),
+        )
+
+        if workspace_user_link.exists():
+            raise serializers.ValidationError({"error": "URL already exists for this workspace and owner"})
+
+        return super().create(validated_data)
+
+    def update(self, instance, validated_data):
+        # Filtering the WorkspaceUserLink with the given url to check if the link already exists.
+
+        url = validated_data.get("url")
+
+        workspace_user_link = WorkspaceUserLink.objects.filter(
+            url=url, workspace_id=instance.workspace_id, owner=instance.owner
+        )
+
+        if workspace_user_link.exclude(pk=instance.id).exists():
+            raise serializers.ValidationError({"error": "URL already exists for this workspace and owner"})
+
+        return super().update(instance, validated_data)
+
+
+class IssueRecentVisitSerializer(serializers.ModelSerializer):
+    project_identifier = serializers.SerializerMethodField()
+    assignees = serializers.SerializerMethodField()
+
+    class Meta:
+        model = Issue
+        fields = [
+            "id",
+            "name",
+            "state",
+            "priority",
+            "assignees",
+            "type",
+            "sequence_id",
+            "project_id",
+            "project_identifier",
+        ]
+
+    def get_project_identifier(self, obj):
+        project = obj.project
+        return project.identifier if project else None
+
+    def get_assignees(self, obj):
+        return list(obj.assignees.filter(issue_assignee__deleted_at__isnull=True).values_list("id", flat=True))
+
+
+class ProjectRecentVisitSerializer(serializers.ModelSerializer):
+    project_members = serializers.SerializerMethodField()
+
+    class Meta:
+        model = Project
+        fields = ["id", "name", "logo_props", "project_members", "identifier"]
+
+    def get_project_members(self, obj):
+        members = ProjectMember.objects.filter(project_id=obj.id, member__is_bot=False, is_active=True).values_list(
+            "member", flat=True
+        )
+
+        return members
+
+
+class PageRecentVisitSerializer(serializers.ModelSerializer):
+    project_id = serializers.SerializerMethodField()
+    project_identifier = serializers.SerializerMethodField()
+
+    class Meta:
+        model = Page
+        fields = [
+            "id",
+            "name",
+            "logo_props",
+            "project_id",
+            "owned_by",
+            "project_identifier",
+        ]
+
+    def get_project_id(self, obj):
+        return obj.project_id if hasattr(obj, "project_id") else obj.projects.values_list("id", flat=True).first()
+
+    def get_project_identifier(self, obj):
+        project = obj.projects.first()
+
+        return project.identifier if project else None
+
+
+def get_entity_model_and_serializer(entity_type):
+    entity_map = {
+        "issue": (Issue, IssueRecentVisitSerializer),
+        "page": (Page, PageRecentVisitSerializer),
+        "project": (Project, ProjectRecentVisitSerializer),
+    }
+    return entity_map.get(entity_type, (None, None))
+
+
+class WorkspaceRecentVisitSerializer(BaseSerializer):
+    entity_data = serializers.SerializerMethodField()
+
+    class Meta:
+        model = UserRecentVisit
+        fields = ["id", "entity_name", "entity_identifier", "entity_data", "visited_at"]
+        read_only_fields = ["workspace", "owner", "created_by", "updated_by"]
+
+    def get_entity_data(self, obj):
+        entity_name = obj.entity_name
+        entity_identifier = obj.entity_identifier
+
+        entity_model, entity_serializer = get_entity_model_and_serializer(entity_name)
+
+        if entity_model and entity_serializer:
+            try:
+                entity = entity_model.objects.get(pk=entity_identifier)
+
+                return entity_serializer(entity).data
+            except entity_model.DoesNotExist:
+                return None
+        return None
+
+
+class WorkspaceHomePreferenceSerializer(BaseSerializer):
+    class Meta:
+        model = WorkspaceHomePreference
+        fields = ["key", "is_enabled", "sort_order"]
+        read_only_fields = ["workspace", "created_by", "updated_by"]
+
+
+class StickySerializer(BaseSerializer):
+    class Meta:
+        model = Sticky
+        fields = "__all__"
+        read_only_fields = ["workspace", "owner"]
+        extra_kwargs = {"name": {"required": False}}
+
+    def validate(self, data):
+        # Validate description content for security
+        if "description_html" in data and data["description_html"]:
+            is_valid, error_msg, sanitized_html = validate_html_content(data["description_html"])
+            if not is_valid:
+                raise serializers.ValidationError({"error": "html content is not valid"})
+            # Update the data with sanitized HTML if available
+            if sanitized_html is not None:
+                data["description_html"] = sanitized_html
+
+        if "description_binary" in data and data["description_binary"]:
+            is_valid, error_msg = validate_binary_data(data["description_binary"])
+            if not is_valid:
+                raise serializers.ValidationError({"description_binary": "Invalid binary data"})
+
+        return data
+
+
+class WorkspaceUserPreferenceSerializer(BaseSerializer):
+    class Meta:
+        model = WorkspaceUserPreference
+        fields = ["key", "is_pinned", "sort_order"]
+        read_only_fields = ["workspace", "created_by", "updated_by"]

plane-src/apps/api/plane/app/urls/__init__.py

@@ -0,0 +1,47 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+from .analytic import urlpatterns as analytic_urls
+from .api import urlpatterns as api_urls
+from .asset import urlpatterns as asset_urls
+from .cycle import urlpatterns as cycle_urls
+from .estimate import urlpatterns as estimate_urls
+from .external import urlpatterns as external_urls
+from .intake import urlpatterns as intake_urls
+from .issue import urlpatterns as issue_urls
+from .module import urlpatterns as module_urls
+from .notification import urlpatterns as notification_urls
+from .page import urlpatterns as page_urls
+from .project import urlpatterns as project_urls
+from .search import urlpatterns as search_urls
+from .state import urlpatterns as state_urls
+from .user import urlpatterns as user_urls
+from .views import urlpatterns as view_urls
+from .webhook import urlpatterns as webhook_urls
+from .workspace import urlpatterns as workspace_urls
+from .timezone import urlpatterns as timezone_urls
+from .exporter import urlpatterns as exporter_urls
+
+urlpatterns = [
+    *analytic_urls,
+    *asset_urls,
+    *cycle_urls,
+    *estimate_urls,
+    *external_urls,
+    *intake_urls,
+    *issue_urls,
+    *module_urls,
+    *notification_urls,
+    *page_urls,
+    *project_urls,
+    *search_urls,
+    *state_urls,
+    *user_urls,
+    *view_urls,
+    *workspace_urls,
+    *api_urls,
+    *webhook_urls,
+    *timezone_urls,
+    *exporter_urls,
+]

plane-src/apps/api/plane/app/urls/analytic.py

@@ -0,0 +1,90 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+from django.urls import path
+
+
+from plane.app.views import (
+    AnalyticsEndpoint,
+    AnalyticViewViewset,
+    SavedAnalyticEndpoint,
+    ExportAnalyticsEndpoint,
+    AdvanceAnalyticsEndpoint,
+    AdvanceAnalyticsStatsEndpoint,
+    AdvanceAnalyticsChartEndpoint,
+    DefaultAnalyticsEndpoint,
+    ProjectStatsEndpoint,
+    ProjectAdvanceAnalyticsEndpoint,
+    ProjectAdvanceAnalyticsStatsEndpoint,
+    ProjectAdvanceAnalyticsChartEndpoint,
+)
+
+
+urlpatterns = [
+    path(
+        "workspaces/<str:slug>/analytics/",
+        AnalyticsEndpoint.as_view(),
+        name="plane-analytics",
+    ),
+    path(
+        "workspaces/<str:slug>/analytic-view/",
+        AnalyticViewViewset.as_view({"get": "list", "post": "create"}),
+        name="analytic-view",
+    ),
+    path(
+        "workspaces/<str:slug>/analytic-view/<uuid:pk>/",
+        AnalyticViewViewset.as_view({"get": "retrieve", "patch": "partial_update", "delete": "destroy"}),
+        name="analytic-view",
+    ),
+    path(
+        "workspaces/<str:slug>/saved-analytic-view/<uuid:analytic_id>/",
+        SavedAnalyticEndpoint.as_view(),
+        name="saved-analytic-view",
+    ),
+    path(
+        "workspaces/<str:slug>/export-analytics/",
+        ExportAnalyticsEndpoint.as_view(),
+        name="export-analytics",
+    ),
+    path(
+        "workspaces/<str:slug>/default-analytics/",
+        DefaultAnalyticsEndpoint.as_view(),
+        name="default-analytics",
+    ),
+    path(
+        "workspaces/<str:slug>/project-stats/",
+        ProjectStatsEndpoint.as_view(),
+        name="project-analytics",
+    ),
+    path(
+        "workspaces/<str:slug>/advance-analytics/",
+        AdvanceAnalyticsEndpoint.as_view(),
+        name="advance-analytics",
+    ),
+    path(
+        "workspaces/<str:slug>/advance-analytics-stats/",
+        AdvanceAnalyticsStatsEndpoint.as_view(),
+        name="advance-analytics-stats",
+    ),
+    path(
+        "workspaces/<str:slug>/advance-analytics-charts/",
+        AdvanceAnalyticsChartEndpoint.as_view(),
+        name="advance-analytics-chart",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/advance-analytics/",
+        ProjectAdvanceAnalyticsEndpoint.as_view(),
+        name="project-advance-analytics",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/advance-analytics-stats/",
+        ProjectAdvanceAnalyticsStatsEndpoint.as_view(),
+        name="project-advance-analytics-stats",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/advance-analytics-charts/",
+        ProjectAdvanceAnalyticsChartEndpoint.as_view(),
+        name="project-advance-analytics-chart",
+    ),
+]

plane-src/apps/api/plane/app/urls/api.py

@@ -0,0 +1,21 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+from django.urls import path
+from plane.app.views import ApiTokenEndpoint
+
+urlpatterns = [
+    # API Tokens
+    path(
+        "users/api-tokens/",
+        ApiTokenEndpoint.as_view(),
+        name="api-tokens",
+    ),
+    path(
+        "users/api-tokens/<uuid:pk>/",
+        ApiTokenEndpoint.as_view(),
+        name="api-tokens-details",
+    ),
+    ## End API Tokens
+]

plane-src/apps/api/plane/app/urls/asset.py

@@ -0,0 +1,114 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+from django.urls import path
+
+
+from plane.app.views import (
+    FileAssetEndpoint,
+    UserAssetsEndpoint,
+    FileAssetViewSet,
+    # V2 Endpoints
+    WorkspaceFileAssetEndpoint,
+    UserAssetsV2Endpoint,
+    StaticFileAssetEndpoint,
+    AssetRestoreEndpoint,
+    ProjectAssetEndpoint,
+    ProjectBulkAssetEndpoint,
+    AssetCheckEndpoint,
+    DuplicateAssetEndpoint,
+    WorkspaceAssetDownloadEndpoint,
+    ProjectAssetDownloadEndpoint,
+)
+
+
+urlpatterns = [
+    path(
+        "workspaces/<str:slug>/file-assets/",
+        FileAssetEndpoint.as_view(),
+        name="file-assets",
+    ),
+    path(
+        "workspaces/file-assets/<uuid:workspace_id>/<str:asset_key>/",
+        FileAssetEndpoint.as_view(),
+        name="file-assets",
+    ),
+    path("users/file-assets/", UserAssetsEndpoint.as_view(), name="user-file-assets"),
+    path(
+        "users/file-assets/<str:asset_key>/",
+        UserAssetsEndpoint.as_view(),
+        name="user-file-assets",
+    ),
+    path(
+        "workspaces/file-assets/<uuid:workspace_id>/<str:asset_key>/restore/",
+        FileAssetViewSet.as_view({"post": "restore"}),
+        name="file-assets-restore",
+    ),
+    # V2 Endpoints
+    path(
+        "assets/v2/workspaces/<str:slug>/",
+        WorkspaceFileAssetEndpoint.as_view(),
+        name="workspace-file-assets",
+    ),
+    path(
+        "assets/v2/workspaces/<str:slug>/<uuid:asset_id>/",
+        WorkspaceFileAssetEndpoint.as_view(),
+        name="workspace-file-assets",
+    ),
+    path(
+        "assets/v2/user-assets/",
+        UserAssetsV2Endpoint.as_view(),
+        name="user-file-assets",
+    ),
+    path(
+        "assets/v2/user-assets/<uuid:asset_id>/",
+        UserAssetsV2Endpoint.as_view(),
+        name="user-file-assets",
+    ),
+    path(
+        "assets/v2/workspaces/<str:slug>/restore/<uuid:asset_id>/",
+        AssetRestoreEndpoint.as_view(),
+        name="asset-restore",
+    ),
+    path(
+        "assets/v2/static/<uuid:asset_id>/",
+        StaticFileAssetEndpoint.as_view(),
+        name="static-file-asset",
+    ),
+    path(
+        "assets/v2/workspaces/<str:slug>/projects/<uuid:project_id>/",
+        ProjectAssetEndpoint.as_view(),
+        name="bulk-asset-update",
+    ),
+    path(
+        "assets/v2/workspaces/<str:slug>/projects/<uuid:project_id>/<uuid:pk>/",
+        ProjectAssetEndpoint.as_view(),
+        name="bulk-asset-update",
+    ),
+    path(
+        "assets/v2/workspaces/<str:slug>/projects/<uuid:project_id>/<uuid:entity_id>/bulk/",
+        ProjectBulkAssetEndpoint.as_view(),
+        name="bulk-asset-update",
+    ),
+    path(
+        "assets/v2/workspaces/<str:slug>/check/<uuid:asset_id>/",
+        AssetCheckEndpoint.as_view(),
+        name="asset-check",
+    ),
+    path(
+        "assets/v2/workspaces/<str:slug>/duplicate-assets/<uuid:asset_id>/",
+        DuplicateAssetEndpoint.as_view(),
+        name="duplicate-assets",
+    ),
+    path(
+        "assets/v2/workspaces/<str:slug>/download/<uuid:asset_id>/",
+        WorkspaceAssetDownloadEndpoint.as_view(),
+        name="workspace-asset-download",
+    ),
+    path(
+        "assets/v2/workspaces/<str:slug>/projects/<uuid:project_id>/download/<uuid:asset_id>/",
+        ProjectAssetDownloadEndpoint.as_view(),
+        name="project-asset-download",
+    ),
+]

plane-src/apps/api/plane/app/urls/cycle.py

@@ -0,0 +1,106 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+from django.urls import path
+
+
+from plane.app.views import (
+    CycleViewSet,
+    CycleIssueViewSet,
+    CycleDateCheckEndpoint,
+    CycleFavoriteViewSet,
+    CycleProgressEndpoint,
+    CycleAnalyticsEndpoint,
+    TransferCycleIssueEndpoint,
+    CycleUserPropertiesEndpoint,
+    CycleArchiveUnarchiveEndpoint,
+)
+
+
+urlpatterns = [
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/cycles/",
+        CycleViewSet.as_view({"get": "list", "post": "create"}),
+        name="project-cycle",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/cycles/<uuid:pk>/",
+        CycleViewSet.as_view(
+            {
+                "get": "retrieve",
+                "put": "update",
+                "patch": "partial_update",
+                "delete": "destroy",
+            }
+        ),
+        name="project-cycle",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/cycles/<uuid:cycle_id>/cycle-issues/",
+        CycleIssueViewSet.as_view({"get": "list", "post": "create"}),
+        name="project-issue-cycle",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/cycles/<uuid:cycle_id>/cycle-issues/<uuid:issue_id>/",
+        CycleIssueViewSet.as_view(
+            {
+                "get": "retrieve",
+                "put": "update",
+                "patch": "partial_update",
+                "delete": "destroy",
+            }
+        ),
+        name="project-issue-cycle",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/cycles/date-check/",
+        CycleDateCheckEndpoint.as_view(),
+        name="project-cycle-date",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/user-favorite-cycles/",
+        CycleFavoriteViewSet.as_view({"get": "list", "post": "create"}),
+        name="user-favorite-cycle",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/user-favorite-cycles/<uuid:cycle_id>/",
+        CycleFavoriteViewSet.as_view({"delete": "destroy"}),
+        name="user-favorite-cycle",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/cycles/<uuid:cycle_id>/transfer-issues/",
+        TransferCycleIssueEndpoint.as_view(),
+        name="transfer-issues",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/cycles/<uuid:cycle_id>/user-properties/",
+        CycleUserPropertiesEndpoint.as_view(),
+        name="cycle-user-filters",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/cycles/<uuid:cycle_id>/archive/",
+        CycleArchiveUnarchiveEndpoint.as_view(),
+        name="cycle-archive-unarchive",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/archived-cycles/",
+        CycleArchiveUnarchiveEndpoint.as_view(),
+        name="cycle-archive-unarchive",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/archived-cycles/<uuid:pk>/",
+        CycleArchiveUnarchiveEndpoint.as_view(),
+        name="cycle-archive-unarchive",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/cycles/<uuid:cycle_id>/progress/",
+        CycleProgressEndpoint.as_view(),
+        name="project-cycle",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/cycles/<uuid:cycle_id>/analytics/",
+        CycleAnalyticsEndpoint.as_view(),
+        name="project-cycle",
+    ),
+]

plane-src/apps/api/plane/app/urls/estimate.py

@@ -0,0 +1,41 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+from django.urls import path
+
+
+from plane.app.views import (
+    ProjectEstimatePointEndpoint,
+    BulkEstimatePointEndpoint,
+    EstimatePointEndpoint,
+)
+
+
+urlpatterns = [
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/project-estimates/",
+        ProjectEstimatePointEndpoint.as_view(),
+        name="project-estimate-points",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/estimates/",
+        BulkEstimatePointEndpoint.as_view({"get": "list", "post": "create"}),
+        name="bulk-create-estimate-points",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/estimates/<uuid:estimate_id>/",
+        BulkEstimatePointEndpoint.as_view({"get": "retrieve", "patch": "partial_update", "delete": "destroy"}),
+        name="bulk-create-estimate-points",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/estimates/<uuid:estimate_id>/estimate-points/",
+        EstimatePointEndpoint.as_view({"post": "create"}),
+        name="estimate-points",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/estimates/<uuid:estimate_id>/estimate-points/<estimate_point_id>/",
+        EstimatePointEndpoint.as_view({"patch": "partial_update", "delete": "destroy"}),
+        name="estimate-points",
+    ),
+]

plane-src/apps/api/plane/app/urls/exporter.py

@@ -0,0 +1,16 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+from django.urls import path
+
+from plane.app.views import ExportIssuesEndpoint
+
+
+urlpatterns = [
+    path(
+        "workspaces/<str:slug>/export-issues/",
+        ExportIssuesEndpoint.as_view(),
+        name="export-issues",
+    ),
+]

plane-src/apps/api/plane/app/urls/external.py

@@ -0,0 +1,24 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+from django.urls import path
+
+
+from plane.app.views import UnsplashEndpoint
+from plane.app.views import GPTIntegrationEndpoint, WorkspaceGPTIntegrationEndpoint
+
+
+urlpatterns = [
+    path("unsplash/", UnsplashEndpoint.as_view(), name="unsplash"),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/ai-assistant/",
+        GPTIntegrationEndpoint.as_view(),
+        name="importer",
+    ),
+    path(
+        "workspaces/<str:slug>/ai-assistant/",
+        WorkspaceGPTIntegrationEndpoint.as_view(),
+        name="importer",
+    ),
+]

plane-src/apps/api/plane/app/urls/intake.py

@@ -0,0 +1,66 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+from django.urls import path
+
+
+from plane.app.views import (
+    IntakeViewSet,
+    IntakeIssueViewSet,
+    IntakeWorkItemDescriptionVersionEndpoint,
+)
+
+
+urlpatterns = [
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/intakes/",
+        IntakeViewSet.as_view({"get": "list", "post": "create"}),
+        name="intake",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/intakes/<uuid:pk>/",
+        IntakeViewSet.as_view({"get": "retrieve", "patch": "partial_update", "delete": "destroy"}),
+        name="intake",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/intake-issues/",
+        IntakeIssueViewSet.as_view({"get": "list", "post": "create"}),
+        name="intake-issue",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/intake-issues/<uuid:pk>/",
+        IntakeIssueViewSet.as_view({"get": "retrieve", "patch": "partial_update", "delete": "destroy"}),
+        name="intake-issue",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/inboxes/",
+        IntakeViewSet.as_view({"get": "list", "post": "create"}),
+        name="inbox",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/inboxes/<uuid:pk>/",
+        IntakeViewSet.as_view({"get": "retrieve", "patch": "partial_update", "delete": "destroy"}),
+        name="inbox",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/inbox-issues/",
+        IntakeIssueViewSet.as_view({"get": "list", "post": "create"}),
+        name="inbox-issue",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/inbox-issues/<uuid:pk>/",
+        IntakeIssueViewSet.as_view({"get": "retrieve", "patch": "partial_update", "delete": "destroy"}),
+        name="inbox-issue",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/intake-work-items/<uuid:work_item_id>/description-versions/",
+        IntakeWorkItemDescriptionVersionEndpoint.as_view(),
+        name="intake-work-item-versions",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/intake-work-items/<uuid:work_item_id>/description-versions/<uuid:pk>/",
+        IntakeWorkItemDescriptionVersionEndpoint.as_view(),
+        name="intake-work-item-versions",
+    ),
+]

plane-src/apps/api/plane/app/urls/issue.py

@@ -0,0 +1,286 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+from django.urls import path
+
+from plane.app.views import (
+    BulkCreateIssueLabelsEndpoint,
+    BulkDeleteIssuesEndpoint,
+    SubIssuesEndpoint,
+    IssueLinkViewSet,
+    IssueAttachmentEndpoint,
+    CommentReactionViewSet,
+    IssueActivityEndpoint,
+    IssueArchiveViewSet,
+    IssueCommentViewSet,
+    IssueListEndpoint,
+    IssueReactionViewSet,
+    IssueRelationViewSet,
+    IssueSubscriberViewSet,
+    ProjectUserDisplayPropertyEndpoint,
+    IssueViewSet,
+    LabelViewSet,
+    BulkArchiveIssuesEndpoint,
+    DeletedIssuesListViewSet,
+    IssuePaginatedViewSet,
+    IssueDetailEndpoint,
+    IssueAttachmentV2Endpoint,
+    IssueBulkUpdateDateEndpoint,
+    IssueVersionEndpoint,
+    WorkItemDescriptionVersionEndpoint,
+    IssueMetaEndpoint,
+    IssueDetailIdentifierEndpoint,
+)
+
+urlpatterns = [
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/list/",
+        IssueListEndpoint.as_view(),
+        name="project-issue",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/",
+        IssueViewSet.as_view({"get": "list", "post": "create"}),
+        name="project-issue",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues-detail/",
+        IssueDetailEndpoint.as_view(),
+        name="project-issue-detail",
+    ),
+    # updated v1 paginated issues
+    # updated v2 paginated issues
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/v2/issues/",
+        IssuePaginatedViewSet.as_view({"get": "list"}),
+        name="project-issues-paginated",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:pk>/",
+        IssueViewSet.as_view(
+            {
+                "get": "retrieve",
+                "put": "update",
+                "patch": "partial_update",
+                "delete": "destroy",
+            }
+        ),
+        name="project-issue",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issue-labels/",
+        LabelViewSet.as_view({"get": "list", "post": "create"}),
+        name="project-issue-labels",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issue-labels/<uuid:pk>/",
+        LabelViewSet.as_view(
+            {
+                "get": "retrieve",
+                "put": "update",
+                "patch": "partial_update",
+                "delete": "destroy",
+            }
+        ),
+        name="project-issue-labels",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/bulk-create-labels/",
+        BulkCreateIssueLabelsEndpoint.as_view(),
+        name="project-bulk-labels",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/bulk-delete-issues/",
+        BulkDeleteIssuesEndpoint.as_view(),
+        name="project-issues-bulk",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/bulk-archive-issues/",
+        BulkArchiveIssuesEndpoint.as_view(),
+        name="bulk-archive-issues",
+    ),
+    ##
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/sub-issues/",
+        SubIssuesEndpoint.as_view(),
+        name="sub-issues",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/issue-links/",
+        IssueLinkViewSet.as_view({"get": "list", "post": "create"}),
+        name="project-issue-links",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/issue-links/<uuid:pk>/",
+        IssueLinkViewSet.as_view(
+            {
+                "get": "retrieve",
+                "put": "update",
+                "patch": "partial_update",
+                "delete": "destroy",
+            }
+        ),
+        name="project-issue-links",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/issue-attachments/",
+        IssueAttachmentEndpoint.as_view(),
+        name="project-issue-attachments",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/issue-attachments/<uuid:pk>/",
+        IssueAttachmentEndpoint.as_view(),
+        name="project-issue-attachments",
+    ),
+    # V2 Attachments
+    path(
+        "assets/v2/workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/attachments/",
+        IssueAttachmentV2Endpoint.as_view(),
+        name="project-issue-attachments",
+    ),
+    path(
+        "assets/v2/workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/attachments/<uuid:pk>/",
+        IssueAttachmentV2Endpoint.as_view(),
+        name="project-issue-attachments",
+    ),
+    ## End Issues
+    ## Issue Activity
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/history/",
+        IssueActivityEndpoint.as_view(),
+        name="project-issue-history",
+    ),
+    ## Issue Activity
+    ## IssueComments
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/comments/",
+        IssueCommentViewSet.as_view({"get": "list", "post": "create"}),
+        name="project-issue-comment",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/comments/<uuid:pk>/",
+        IssueCommentViewSet.as_view(
+            {
+                "get": "retrieve",
+                "put": "update",
+                "patch": "partial_update",
+                "delete": "destroy",
+            }
+        ),
+        name="project-issue-comment",
+    ),
+    ## End IssueComments
+    # Issue Subscribers
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/issue-subscribers/",
+        IssueSubscriberViewSet.as_view({"get": "list", "post": "create"}),
+        name="project-issue-subscribers",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/issue-subscribers/<uuid:subscriber_id>/",
+        IssueSubscriberViewSet.as_view({"delete": "destroy"}),
+        name="project-issue-subscribers",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/subscribe/",
+        IssueSubscriberViewSet.as_view({"get": "subscription_status", "post": "subscribe", "delete": "unsubscribe"}),
+        name="project-issue-subscribers",
+    ),
+    ## End Issue Subscribers
+    # Issue Reactions
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/reactions/",
+        IssueReactionViewSet.as_view({"get": "list", "post": "create"}),
+        name="project-issue-reactions",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/reactions/<str:reaction_code>/",
+        IssueReactionViewSet.as_view({"delete": "destroy"}),
+        name="project-issue-reactions",
+    ),
+    ## End Issue Reactions
+    # Comment Reactions
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/comments/<uuid:comment_id>/reactions/",
+        CommentReactionViewSet.as_view({"get": "list", "post": "create"}),
+        name="project-issue-comment-reactions",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/comments/<uuid:comment_id>/reactions/<str:reaction_code>/",
+        CommentReactionViewSet.as_view({"delete": "destroy"}),
+        name="project-issue-comment-reactions",
+    ),
+    ## End Comment Reactions
+    ## ProjectUserProperty
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/user-properties/",
+        ProjectUserDisplayPropertyEndpoint.as_view(),
+        name="project-issue-display-properties",
+    ),
+    ## ProjectUserProperty End
+    ## Issue Archives
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/archived-issues/",
+        IssueArchiveViewSet.as_view({"get": "list"}),
+        name="project-issue-archive",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:pk>/archive/",
+        IssueArchiveViewSet.as_view({"get": "retrieve", "post": "archive", "delete": "unarchive"}),
+        name="project-issue-archive-unarchive",
+    ),
+    ## End Issue Archives
+    ## Issue Relation
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/issue-relation/",
+        IssueRelationViewSet.as_view({"get": "list", "post": "create"}),
+        name="issue-relation",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/remove-relation/",
+        IssueRelationViewSet.as_view({"post": "remove_relation"}),
+        name="issue-relation",
+    ),
+    ## End Issue Relation
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/deleted-issues/",
+        DeletedIssuesListViewSet.as_view(),
+        name="deleted-issues",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issue-dates/",
+        IssueBulkUpdateDateEndpoint.as_view(),
+        name="project-issue-dates",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/versions/",
+        IssueVersionEndpoint.as_view(),
+        name="issue-versions",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/versions/<uuid:pk>/",
+        IssueVersionEndpoint.as_view(),
+        name="issue-versions",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/work-items/<uuid:work_item_id>/description-versions/",
+        WorkItemDescriptionVersionEndpoint.as_view(),
+        name="work-item-versions",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/work-items/<uuid:work_item_id>/description-versions/<uuid:pk>/",
+        WorkItemDescriptionVersionEndpoint.as_view(),
+        name="work-item-versions",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/meta/",
+        IssueMetaEndpoint.as_view(),
+        name="issue-meta",
+    ),
+    path(
+        "workspaces/<str:slug>/work-items/<str:project_identifier>-<str:issue_identifier>/",
+        IssueDetailIdentifierEndpoint.as_view(),
+        name="issue-detail-identifier",
+    ),
+]

plane-src/apps/api/plane/app/urls/module.py

@@ -0,0 +1,105 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+from django.urls import path
+
+
+from plane.app.views import (
+    ModuleViewSet,
+    ModuleIssueViewSet,
+    ModuleLinkViewSet,
+    ModuleFavoriteViewSet,
+    ModuleUserPropertiesEndpoint,
+    ModuleArchiveUnarchiveEndpoint,
+)
+
+
+urlpatterns = [
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/modules/",
+        ModuleViewSet.as_view({"get": "list", "post": "create"}),
+        name="project-modules",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/modules/<uuid:pk>/",
+        ModuleViewSet.as_view(
+            {
+                "get": "retrieve",
+                "put": "update",
+                "patch": "partial_update",
+                "delete": "destroy",
+            }
+        ),
+        name="project-modules",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/modules/",
+        ModuleIssueViewSet.as_view({"post": "create_issue_modules"}),
+        name="issue-module",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/modules/<uuid:module_id>/issues/",
+        ModuleIssueViewSet.as_view({"post": "create_module_issues", "get": "list"}),
+        name="project-module-issues",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/modules/<uuid:module_id>/issues/<uuid:issue_id>/",
+        ModuleIssueViewSet.as_view(
+            {
+                "get": "retrieve",
+                "put": "update",
+                "patch": "partial_update",
+                "delete": "destroy",
+            }
+        ),
+        name="project-module-issues",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/modules/<uuid:module_id>/module-links/",
+        ModuleLinkViewSet.as_view({"get": "list", "post": "create"}),
+        name="project-issue-module-links",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/modules/<uuid:module_id>/module-links/<uuid:pk>/",
+        ModuleLinkViewSet.as_view(
+            {
+                "get": "retrieve",
+                "put": "update",
+                "patch": "partial_update",
+                "delete": "destroy",
+            }
+        ),
+        name="project-issue-module-links",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/user-favorite-modules/",
+        ModuleFavoriteViewSet.as_view({"get": "list", "post": "create"}),
+        name="user-favorite-module",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/user-favorite-modules/<uuid:module_id>/",
+        ModuleFavoriteViewSet.as_view({"delete": "destroy"}),
+        name="user-favorite-module",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/modules/<uuid:module_id>/user-properties/",
+        ModuleUserPropertiesEndpoint.as_view(),
+        name="cycle-user-filters",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/modules/<uuid:module_id>/archive/",
+        ModuleArchiveUnarchiveEndpoint.as_view(),
+        name="module-archive-unarchive",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/archived-modules/",
+        ModuleArchiveUnarchiveEndpoint.as_view(),
+        name="module-archive-unarchive",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/archived-modules/<uuid:pk>/",
+        ModuleArchiveUnarchiveEndpoint.as_view(),
+        name="module-archive-unarchive",
+    ),
+]

plane-src/apps/api/plane/app/urls/notification.py

@@ -0,0 +1,52 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+from django.urls import path
+
+
+from plane.app.views import (
+    NotificationViewSet,
+    UnreadNotificationEndpoint,
+    MarkAllReadNotificationViewSet,
+    UserNotificationPreferenceEndpoint,
+)
+
+
+urlpatterns = [
+    path(
+        "workspaces/<str:slug>/users/notifications/",
+        NotificationViewSet.as_view({"get": "list"}),
+        name="notifications",
+    ),
+    path(
+        "workspaces/<str:slug>/users/notifications/<uuid:pk>/",
+        NotificationViewSet.as_view({"get": "retrieve", "patch": "partial_update", "delete": "destroy"}),
+        name="notifications",
+    ),
+    path(
+        "workspaces/<str:slug>/users/notifications/<uuid:pk>/read/",
+        NotificationViewSet.as_view({"post": "mark_read", "delete": "mark_unread"}),
+        name="notifications",
+    ),
+    path(
+        "workspaces/<str:slug>/users/notifications/<uuid:pk>/archive/",
+        NotificationViewSet.as_view({"post": "archive", "delete": "unarchive"}),
+        name="notifications",
+    ),
+    path(
+        "workspaces/<str:slug>/users/notifications/unread/",
+        UnreadNotificationEndpoint.as_view(),
+        name="unread-notifications",
+    ),
+    path(
+        "workspaces/<str:slug>/users/notifications/mark-all-read/",
+        MarkAllReadNotificationViewSet.as_view({"post": "create"}),
+        name="mark-all-read-notifications",
+    ),
+    path(
+        "users/me/notification-preferences/",
+        UserNotificationPreferenceEndpoint.as_view(),
+        name="user-notification-preferences",
+    ),
+]

plane-src/apps/api/plane/app/urls/page.py

@@ -0,0 +1,76 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+from django.urls import path
+
+
+from plane.app.views import (
+    PageViewSet,
+    PageFavoriteViewSet,
+    PagesDescriptionViewSet,
+    PageVersionEndpoint,
+    PageDuplicateEndpoint,
+)
+
+urlpatterns = [
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/pages-summary/",
+        PageViewSet.as_view({"get": "summary"}),
+        name="project-pages-summary",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/pages/",
+        PageViewSet.as_view({"get": "list", "post": "create"}),
+        name="project-pages",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/pages/<uuid:page_id>/",
+        PageViewSet.as_view({"get": "retrieve", "patch": "partial_update", "delete": "destroy"}),
+        name="project-pages",
+    ),
+    # favorite pages
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/favorite-pages/<uuid:page_id>/",
+        PageFavoriteViewSet.as_view({"post": "create", "delete": "destroy"}),
+        name="user-favorite-pages",
+    ),
+    # archived pages
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/pages/<uuid:page_id>/archive/",
+        PageViewSet.as_view({"post": "archive", "delete": "unarchive"}),
+        name="project-page-archive-unarchive",
+    ),
+    # lock and unlock
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/pages/<uuid:page_id>/lock/",
+        PageViewSet.as_view({"post": "lock", "delete": "unlock"}),
+        name="project-pages-lock-unlock",
+    ),
+    # private and public page
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/pages/<uuid:page_id>/access/",
+        PageViewSet.as_view({"post": "access"}),
+        name="project-pages-access",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/pages/<uuid:page_id>/description/",
+        PagesDescriptionViewSet.as_view({"get": "retrieve", "patch": "partial_update"}),
+        name="page-description",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/pages/<uuid:page_id>/versions/",
+        PageVersionEndpoint.as_view(),
+        name="page-versions",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/pages/<uuid:page_id>/versions/<uuid:pk>/",
+        PageVersionEndpoint.as_view(),
+        name="page-versions",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/pages/<uuid:page_id>/duplicate/",
+        PageDuplicateEndpoint.as_view(),
+        name="page-duplicate",
+    ),
+]

plane-src/apps/api/plane/app/urls/project.py

@@ -0,0 +1,132 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+from django.urls import path
+
+from plane.app.views import (
+    ProjectViewSet,
+    DeployBoardViewSet,
+    ProjectInvitationsViewset,
+    ProjectMemberViewSet,
+    ProjectMemberUserEndpoint,
+    ProjectJoinEndpoint,
+    ProjectUserViewsEndpoint,
+    ProjectIdentifierEndpoint,
+    ProjectFavoritesViewSet,
+    UserProjectInvitationsViewset,
+    UserProjectRolesEndpoint,
+    ProjectArchiveUnarchiveEndpoint,
+    ProjectMemberPreferenceEndpoint,
+)
+
+
+urlpatterns = [
+    path(
+        "workspaces/<str:slug>/projects/",
+        ProjectViewSet.as_view({"get": "list", "post": "create"}),
+        name="project",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/details/",
+        ProjectViewSet.as_view({"get": "list_detail"}),
+        name="project",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:pk>/",
+        ProjectViewSet.as_view(
+            {
+                "get": "retrieve",
+                "put": "update",
+                "patch": "partial_update",
+                "delete": "destroy",
+            }
+        ),
+        name="project",
+    ),
+    path(
+        "workspaces/<str:slug>/project-identifiers/",
+        ProjectIdentifierEndpoint.as_view(),
+        name="project-identifiers",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/invitations/",
+        ProjectInvitationsViewset.as_view({"get": "list", "post": "create"}),
+        name="project-member-invite",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/invitations/<uuid:pk>/",
+        ProjectInvitationsViewset.as_view({"get": "retrieve", "delete": "destroy"}),
+        name="project-member-invite",
+    ),
+    path(
+        "users/me/workspaces/<str:slug>/projects/invitations/",
+        UserProjectInvitationsViewset.as_view({"get": "list", "post": "create"}),
+        name="user-project-invitations",
+    ),
+    path(
+        "users/me/workspaces/<str:slug>/project-roles/",
+        UserProjectRolesEndpoint.as_view(),
+        name="user-project-roles",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/join/<uuid:pk>/",
+        ProjectJoinEndpoint.as_view(),
+        name="project-join",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/members/",
+        ProjectMemberViewSet.as_view({"get": "list", "post": "create"}),
+        name="project-member",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/members/<uuid:pk>/",
+        ProjectMemberViewSet.as_view({"get": "retrieve", "patch": "partial_update", "delete": "destroy"}),
+        name="project-member",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/members/leave/",
+        ProjectMemberViewSet.as_view({"post": "leave"}),
+        name="project-member",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/project-views/",
+        ProjectUserViewsEndpoint.as_view(),
+        name="project-view",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/project-members/me/",
+        ProjectMemberUserEndpoint.as_view(),
+        name="project-member-view",
+    ),
+    path(
+        "workspaces/<str:slug>/user-favorite-projects/",
+        ProjectFavoritesViewSet.as_view({"get": "list", "post": "create"}),
+        name="project-favorite",
+    ),
+    path(
+        "workspaces/<str:slug>/user-favorite-projects/<uuid:project_id>/",
+        ProjectFavoritesViewSet.as_view({"delete": "destroy"}),
+        name="project-favorite",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/project-deploy-boards/",
+        DeployBoardViewSet.as_view({"get": "list", "post": "create"}),
+        name="project-deploy-board",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/project-deploy-boards/<uuid:pk>/",
+        DeployBoardViewSet.as_view({"get": "retrieve", "patch": "partial_update", "delete": "destroy"}),
+        name="project-deploy-board",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/archive/",
+        ProjectArchiveUnarchiveEndpoint.as_view(),
+        name="project-archive-unarchive",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/preferences/member/<uuid:member_id>/",
+        ProjectMemberPreferenceEndpoint.as_view(),
+        name="project-member-preference",
+    ),
+]

plane-src/apps/api/plane/app/urls/search.py

@@ -0,0 +1,27 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+from django.urls import path
+
+
+from plane.app.views import GlobalSearchEndpoint, IssueSearchEndpoint, SearchEndpoint
+
+
+urlpatterns = [
+    path(
+        "workspaces/<str:slug>/search/",
+        GlobalSearchEndpoint.as_view(),
+        name="global-search",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/search-issues/",
+        IssueSearchEndpoint.as_view(),
+        name="project-issue-search",
+    ),
+    path(
+        "workspaces/<str:slug>/entity-search/",
+        SearchEndpoint.as_view(),
+        name="entity-search",
+    ),
+]

plane-src/apps/api/plane/app/urls/state.py

@@ -0,0 +1,32 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+from django.urls import path
+
+
+from plane.app.views import StateViewSet, IntakeStateEndpoint
+
+
+urlpatterns = [
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/states/",
+        StateViewSet.as_view({"get": "list", "post": "create"}),
+        name="project-states",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/states/<uuid:pk>/",
+        StateViewSet.as_view({"get": "retrieve", "patch": "partial_update", "delete": "destroy"}),
+        name="project-state",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/intake-state/",
+        IntakeStateEndpoint.as_view(),
+        name="intake-state",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/states/<uuid:pk>/mark-default/",
+        StateViewSet.as_view({"post": "mark_as_default"}),
+        name="project-state",
+    ),
+]

plane-src/apps/api/plane/app/urls/timezone.py

@@ -0,0 +1,12 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+from django.urls import path
+
+from plane.app.views import TimezoneEndpoint
+
+urlpatterns = [
+    # timezone endpoint
+    path("timezones/", TimezoneEndpoint.as_view(), name="timezone-list")
+]

plane-src/apps/api/plane/app/urls/user.py

@@ -0,0 +1,85 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+from django.urls import path
+
+from plane.app.views import (
+    AccountEndpoint,
+    ProfileEndpoint,
+    UpdateUserOnBoardedEndpoint,
+    UpdateUserTourCompletedEndpoint,
+    UserActivityEndpoint,
+    UserActivityGraphEndpoint,
+    ## User
+    UserEndpoint,
+    UserIssueCompletedGraphEndpoint,
+    UserWorkspaceDashboardEndpoint,
+    UserSessionEndpoint,
+    ## End User
+    ## Workspaces
+    UserWorkSpacesEndpoint,
+)
+
+urlpatterns = [
+    # User Profile
+    path(
+        "users/me/",
+        UserEndpoint.as_view({"get": "retrieve", "patch": "partial_update", "delete": "deactivate"}),
+        name="users",
+    ),
+    path("users/session/", UserSessionEndpoint.as_view(), name="user-session"),
+    path(
+        "users/me/settings/",
+        UserEndpoint.as_view({"get": "retrieve_user_settings"}),
+        name="users",
+    ),
+    path(
+        "users/me/email/generate-code/",
+        UserEndpoint.as_view({"post": "generate_email_verification_code"}),
+        name="user-email-verify-code",
+    ),
+    path(
+        "users/me/email/",
+        UserEndpoint.as_view({"patch": "update_email"}),
+        name="user-email-update",
+    ),
+    # Profile
+    path("users/me/profile/", ProfileEndpoint.as_view(), name="accounts"),
+    # End profile
+    # Accounts
+    path("users/me/accounts/", AccountEndpoint.as_view(), name="accounts"),
+    path("users/me/accounts/<uuid:pk>/", AccountEndpoint.as_view(), name="accounts"),
+    ## End Accounts
+    path(
+        "users/me/instance-admin/",
+        UserEndpoint.as_view({"get": "retrieve_instance_admin"}),
+        name="users",
+    ),
+    path("users/me/onboard/", UpdateUserOnBoardedEndpoint.as_view(), name="user-onboard"),
+    path(
+        "users/me/tour-completed/",
+        UpdateUserTourCompletedEndpoint.as_view(),
+        name="user-tour",
+    ),
+    path("users/me/activities/", UserActivityEndpoint.as_view(), name="user-activities"),
+    # user workspaces
+    path("users/me/workspaces/", UserWorkSpacesEndpoint.as_view(), name="user-workspace"),
+    # User Graphs
+    path(
+        "users/me/workspaces/<str:slug>/activity-graph/",
+        UserActivityGraphEndpoint.as_view(),
+        name="user-activity-graph",
+    ),
+    path(
+        "users/me/workspaces/<str:slug>/issues-completed-graph/",
+        UserIssueCompletedGraphEndpoint.as_view(),
+        name="completed-graph",
+    ),
+    path(
+        "users/me/workspaces/<str:slug>/dashboard/",
+        UserWorkspaceDashboardEndpoint.as_view(),
+        name="user-workspace-dashboard",
+    ),
+    ## End User Graph
+]

plane-src/apps/api/plane/app/urls/views.py

@@ -0,0 +1,66 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+from django.urls import path
+
+
+from plane.app.views import (
+    IssueViewViewSet,
+    WorkspaceViewViewSet,
+    WorkspaceViewIssuesViewSet,
+    IssueViewFavoriteViewSet,
+)
+
+
+urlpatterns = [
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/views/",
+        IssueViewViewSet.as_view({"get": "list", "post": "create"}),
+        name="project-view",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/views/<uuid:pk>/",
+        IssueViewViewSet.as_view(
+            {
+                "get": "retrieve",
+                "put": "update",
+                "patch": "partial_update",
+                "delete": "destroy",
+            }
+        ),
+        name="project-view",
+    ),
+    path(
+        "workspaces/<str:slug>/views/",
+        WorkspaceViewViewSet.as_view({"get": "list", "post": "create"}),
+        name="global-view",
+    ),
+    path(
+        "workspaces/<str:slug>/views/<uuid:pk>/",
+        WorkspaceViewViewSet.as_view(
+            {
+                "get": "retrieve",
+                "put": "update",
+                "patch": "partial_update",
+                "delete": "destroy",
+            }
+        ),
+        name="global-view",
+    ),
+    path(
+        "workspaces/<str:slug>/issues/",
+        WorkspaceViewIssuesViewSet.as_view({"get": "list"}),
+        name="global-view-issues",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/user-favorite-views/",
+        IssueViewFavoriteViewSet.as_view({"get": "list", "post": "create"}),
+        name="user-favorite-view",
+    ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/user-favorite-views/<uuid:view_id>/",
+        IssueViewFavoriteViewSet.as_view({"delete": "destroy"}),
+        name="user-favorite-view",
+    ),
+]

plane-src/apps/api/plane/app/urls/webhook.py

@@ -0,0 +1,31 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+from django.urls import path
+
+from plane.app.views import (
+    WebhookEndpoint,
+    WebhookLogsEndpoint,
+    WebhookSecretRegenerateEndpoint,
+)
+
+
+urlpatterns = [
+    path("workspaces/<str:slug>/webhooks/", WebhookEndpoint.as_view(), name="webhooks"),
+    path(
+        "workspaces/<str:slug>/webhooks/<uuid:pk>/",
+        WebhookEndpoint.as_view(),
+        name="webhooks",
+    ),
+    path(
+        "workspaces/<str:slug>/webhooks/<uuid:pk>/regenerate/",
+        WebhookSecretRegenerateEndpoint.as_view(),
+        name="webhooks",
+    ),
+    path(
+        "workspaces/<str:slug>/webhook-logs/<uuid:webhook_id>/",
+        WebhookLogsEndpoint.as_view(),
+        name="webhooks",
+    ),
+]

plane-src/apps/api/plane/app/urls/workspace.py

@@ -0,0 +1,260 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+from django.urls import path
+
+
+from plane.app.views import (
+    UserWorkspaceInvitationsViewSet,
+    WorkSpaceViewSet,
+    WorkspaceJoinEndpoint,
+    WorkSpaceMemberViewSet,
+    WorkspaceInvitationsViewset,
+    WorkspaceMemberUserEndpoint,
+    WorkspaceMemberUserViewsEndpoint,
+    WorkSpaceAvailabilityCheckEndpoint,
+    UserLastProjectWithWorkspaceEndpoint,
+    WorkspaceThemeViewSet,
+    WorkspaceUserProfileStatsEndpoint,
+    WorkspaceUserActivityEndpoint,
+    WorkspaceUserProfileEndpoint,
+    WorkspaceUserProfileIssuesEndpoint,
+    WorkspaceLabelsEndpoint,
+    WorkspaceProjectMemberEndpoint,
+    WorkspaceUserPropertiesEndpoint,
+    WorkspaceStatesEndpoint,
+    WorkspaceEstimatesEndpoint,
+    ExportWorkspaceUserActivityEndpoint,
+    WorkspaceModulesEndpoint,
+    WorkspaceCyclesEndpoint,
+    WorkspaceFavoriteEndpoint,
+    WorkspaceFavoriteGroupEndpoint,
+    WorkspaceDraftIssueViewSet,
+    QuickLinkViewSet,
+    UserRecentVisitViewSet,
+    WorkspaceHomePreferenceViewSet,
+    WorkspaceStickyViewSet,
+    WorkspaceUserPreferenceViewSet,
+)
+
+
+urlpatterns = [
+    path(
+        "workspace-slug-check/",
+        WorkSpaceAvailabilityCheckEndpoint.as_view(),
+        name="workspace-availability",
+    ),
+    path(
+        "workspaces/",
+        WorkSpaceViewSet.as_view({"get": "list", "post": "create"}),
+        name="workspace",
+    ),
+    path(
+        "workspaces/<str:slug>/",
+        WorkSpaceViewSet.as_view(
+            {
+                "get": "retrieve",
+                "put": "update",
+                "patch": "partial_update",
+                "delete": "destroy",
+            }
+        ),
+        name="workspace",
+    ),
+    path(
+        "workspaces/<str:slug>/invitations/",
+        WorkspaceInvitationsViewset.as_view({"get": "list", "post": "create"}),
+        name="workspace-invitations",
+    ),
+    path(
+        "workspaces/<str:slug>/invitations/<uuid:pk>/",
+        WorkspaceInvitationsViewset.as_view({"delete": "destroy", "get": "retrieve", "patch": "partial_update"}),
+        name="workspace-invitations",
+    ),
+    # user workspace invitations
+    path(
+        "users/me/workspaces/invitations/",
+        UserWorkspaceInvitationsViewSet.as_view({"get": "list", "post": "create"}),
+        name="user-workspace-invitations",
+    ),
+    path(
+        "workspaces/<str:slug>/invitations/<uuid:pk>/join/",
+        WorkspaceJoinEndpoint.as_view(),
+        name="workspace-join",
+    ),
+    # user join workspace
+    path(
+        "workspaces/<str:slug>/members/",
+        WorkSpaceMemberViewSet.as_view({"get": "list"}),
+        name="workspace-member",
+    ),
+    path(
+        "workspaces/<str:slug>/project-members/",
+        WorkspaceProjectMemberEndpoint.as_view(),
+        name="workspace-member-roles",
+    ),
+    path(
+        "workspaces/<str:slug>/members/<uuid:pk>/",
+        WorkSpaceMemberViewSet.as_view({"patch": "partial_update", "delete": "destroy", "get": "retrieve"}),
+        name="workspace-member",
+    ),
+    path(
+        "workspaces/<str:slug>/members/leave/",
+        WorkSpaceMemberViewSet.as_view({"post": "leave"}),
+        name="leave-workspace-members",
+    ),
+    path(
+        "users/last-visited-workspace/",
+        UserLastProjectWithWorkspaceEndpoint.as_view(),
+        name="workspace-project-details",
+    ),
+    path(
+        "workspaces/<str:slug>/workspace-members/me/",
+        WorkspaceMemberUserEndpoint.as_view(),
+        name="workspace-member-details",
+    ),
+    path(
+        "workspaces/<str:slug>/workspace-views/",
+        WorkspaceMemberUserViewsEndpoint.as_view(),
+        name="workspace-member-views-details",
+    ),
+    path(
+        "workspaces/<str:slug>/workspace-themes/",
+        WorkspaceThemeViewSet.as_view({"get": "list", "post": "create"}),
+        name="workspace-themes",
+    ),
+    path(
+        "workspaces/<str:slug>/workspace-themes/<uuid:pk>/",
+        WorkspaceThemeViewSet.as_view({"get": "retrieve", "patch": "partial_update", "delete": "destroy"}),
+        name="workspace-themes",
+    ),
+    path(
+        "workspaces/<str:slug>/user-stats/<uuid:user_id>/",
+        WorkspaceUserProfileStatsEndpoint.as_view(),
+        name="workspace-user-stats",
+    ),
+    path(
+        "workspaces/<str:slug>/user-activity/<uuid:user_id>/",
+        WorkspaceUserActivityEndpoint.as_view(),
+        name="workspace-user-activity",
+    ),
+    path(
+        "workspaces/<str:slug>/user-activity/<uuid:user_id>/export/",
+        ExportWorkspaceUserActivityEndpoint.as_view(),
+        name="export-workspace-user-activity",
+    ),
+    path(
+        "workspaces/<str:slug>/user-profile/<uuid:user_id>/",
+        WorkspaceUserProfileEndpoint.as_view(),
+        name="workspace-user-profile-page",
+    ),
+    path(
+        "workspaces/<str:slug>/user-issues/<uuid:user_id>/",
+        WorkspaceUserProfileIssuesEndpoint.as_view(),
+        name="workspace-user-profile-issues",
+    ),
+    path(
+        "workspaces/<str:slug>/labels/",
+        WorkspaceLabelsEndpoint.as_view(),
+        name="workspace-labels",
+    ),
+    path(
+        "workspaces/<str:slug>/user-properties/",
+        WorkspaceUserPropertiesEndpoint.as_view(),
+        name="workspace-user-filters",
+    ),
+    path(
+        "workspaces/<str:slug>/states/",
+        WorkspaceStatesEndpoint.as_view(),
+        name="workspace-state",
+    ),
+    path(
+        "workspaces/<str:slug>/estimates/",
+        WorkspaceEstimatesEndpoint.as_view(),
+        name="workspace-estimate",
+    ),
+    path(
+        "workspaces/<str:slug>/modules/",
+        WorkspaceModulesEndpoint.as_view(),
+        name="workspace-modules",
+    ),
+    path(
+        "workspaces/<str:slug>/cycles/",
+        WorkspaceCyclesEndpoint.as_view(),
+        name="workspace-cycles",
+    ),
+    path(
+        "workspaces/<str:slug>/user-favorites/",
+        WorkspaceFavoriteEndpoint.as_view(),
+        name="workspace-user-favorites",
+    ),
+    path(
+        "workspaces/<str:slug>/user-favorites/<uuid:favorite_id>/",
+        WorkspaceFavoriteEndpoint.as_view(),
+        name="workspace-user-favorites",
+    ),
+    path(
+        "workspaces/<str:slug>/user-favorites/<uuid:favorite_id>/group/",
+        WorkspaceFavoriteGroupEndpoint.as_view(),
+        name="workspace-user-favorites-groups",
+    ),
+    path(
+        "workspaces/<str:slug>/draft-issues/",
+        WorkspaceDraftIssueViewSet.as_view({"get": "list", "post": "create"}),
+        name="workspace-draft-issues",
+    ),
+    path(
+        "workspaces/<str:slug>/draft-issues/<uuid:pk>/",
+        WorkspaceDraftIssueViewSet.as_view({"get": "retrieve", "patch": "partial_update", "delete": "destroy"}),
+        name="workspace-drafts-issues",
+    ),
+    path(
+        "workspaces/<str:slug>/draft-to-issue/<uuid:draft_id>/",
+        WorkspaceDraftIssueViewSet.as_view({"post": "create_draft_to_issue"}),
+        name="workspace-drafts-issues",
+    ),
+    # quick link
+    path(
+        "workspaces/<str:slug>/quick-links/",
+        QuickLinkViewSet.as_view({"get": "list", "post": "create"}),
+        name="workspace-quick-links",
+    ),
+    path(
+        "workspaces/<str:slug>/quick-links/<uuid:pk>/",
+        QuickLinkViewSet.as_view({"get": "retrieve", "patch": "partial_update", "delete": "destroy"}),
+        name="workspace-quick-links",
+    ),
+    # Widgets
+    path(
+        "workspaces/<str:slug>/home-preferences/",
+        WorkspaceHomePreferenceViewSet.as_view(),
+        name="workspace-home-preference",
+    ),
+    path(
+        "workspaces/<str:slug>/home-preferences/<str:key>/",
+        WorkspaceHomePreferenceViewSet.as_view(),
+        name="workspace-home-preference",
+    ),
+    path(
+        "workspaces/<str:slug>/recent-visits/",
+        UserRecentVisitViewSet.as_view({"get": "list"}),
+        name="workspace-recent-visits",
+    ),
+    path(
+        "workspaces/<str:slug>/stickies/",
+        WorkspaceStickyViewSet.as_view({"get": "list", "post": "create"}),
+        name="workspace-sticky",
+    ),
+    path(
+        "workspaces/<str:slug>/stickies/<uuid:pk>/",
+        WorkspaceStickyViewSet.as_view({"get": "retrieve", "patch": "partial_update", "delete": "destroy"}),
+        name="workspace-sticky",
+    ),
+    # User Preference
+    path(
+        "workspaces/<str:slug>/sidebar-preferences/",
+        WorkspaceUserPreferenceViewSet.as_view(),
+        name="workspace-user-preference",
+    ),
+]

plane-src/apps/api/plane/app/views/__init__.py

@@ -0,0 +1,240 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+from .project.base import (
+    ProjectViewSet,
+    ProjectIdentifierEndpoint,
+    ProjectUserViewsEndpoint,
+    ProjectFavoritesViewSet,
+    DeployBoardViewSet,
+    ProjectArchiveUnarchiveEndpoint,
+)
+
+from .project.invite import (
+    UserProjectInvitationsViewset,
+    ProjectInvitationsViewset,
+    ProjectJoinEndpoint,
+)
+
+from .project.member import (
+    ProjectMemberViewSet,
+    ProjectMemberUserEndpoint,
+    UserProjectRolesEndpoint,
+    ProjectMemberPreferenceEndpoint,
+)
+
+from .user.base import (
+    UserEndpoint,
+    UpdateUserOnBoardedEndpoint,
+    UpdateUserTourCompletedEndpoint,
+    UserActivityEndpoint,
+)
+
+
+from .base import BaseAPIView, BaseViewSet
+
+from .workspace.base import (
+    WorkSpaceViewSet,
+    UserWorkSpacesEndpoint,
+    WorkSpaceAvailabilityCheckEndpoint,
+    UserWorkspaceDashboardEndpoint,
+    WorkspaceThemeViewSet,
+    ExportWorkspaceUserActivityEndpoint,
+)
+
+from .workspace.draft import WorkspaceDraftIssueViewSet
+
+from .workspace.home import WorkspaceHomePreferenceViewSet
+
+from .workspace.favorite import (
+    WorkspaceFavoriteEndpoint,
+    WorkspaceFavoriteGroupEndpoint,
+)
+from .workspace.recent_visit import UserRecentVisitViewSet
+from .workspace.user_preference import WorkspaceUserPreferenceViewSet
+
+from .workspace.member import (
+    WorkSpaceMemberViewSet,
+    WorkspaceMemberUserEndpoint,
+    WorkspaceProjectMemberEndpoint,
+    WorkspaceMemberUserViewsEndpoint,
+)
+from .workspace.invite import (
+    WorkspaceInvitationsViewset,
+    WorkspaceJoinEndpoint,
+    UserWorkspaceInvitationsViewSet,
+)
+from .workspace.label import WorkspaceLabelsEndpoint
+from .workspace.state import WorkspaceStatesEndpoint
+from .workspace.user import (
+    UserLastProjectWithWorkspaceEndpoint,
+    WorkspaceUserProfileIssuesEndpoint,
+    WorkspaceUserPropertiesEndpoint,
+    WorkspaceUserProfileEndpoint,
+    WorkspaceUserActivityEndpoint,
+    WorkspaceUserProfileStatsEndpoint,
+    UserActivityGraphEndpoint,
+    UserIssueCompletedGraphEndpoint,
+)
+from .workspace.estimate import WorkspaceEstimatesEndpoint
+from .workspace.module import WorkspaceModulesEndpoint
+from .workspace.cycle import WorkspaceCyclesEndpoint
+from .workspace.quick_link import QuickLinkViewSet
+from .workspace.sticky import WorkspaceStickyViewSet
+
+from .state.base import StateViewSet, IntakeStateEndpoint
+from .view.base import (
+    WorkspaceViewViewSet,
+    WorkspaceViewIssuesViewSet,
+    IssueViewViewSet,
+    IssueViewFavoriteViewSet,
+)
+from .cycle.base import (
+    CycleViewSet,
+    CycleDateCheckEndpoint,
+    CycleFavoriteViewSet,
+    TransferCycleIssueEndpoint,
+    CycleUserPropertiesEndpoint,
+    CycleAnalyticsEndpoint,
+    CycleProgressEndpoint,
+)
+from .cycle.issue import CycleIssueViewSet
+from .cycle.archive import CycleArchiveUnarchiveEndpoint
+
+from .asset.base import FileAssetEndpoint, UserAssetsEndpoint, FileAssetViewSet
+from .asset.v2 import (
+    WorkspaceFileAssetEndpoint,
+    UserAssetsV2Endpoint,
+    StaticFileAssetEndpoint,
+    AssetRestoreEndpoint,
+    ProjectAssetEndpoint,
+    ProjectBulkAssetEndpoint,
+    AssetCheckEndpoint,
+    DuplicateAssetEndpoint,
+    WorkspaceAssetDownloadEndpoint,
+    ProjectAssetDownloadEndpoint,
+)
+from .issue.base import (
+    IssueListEndpoint,
+    IssueViewSet,
+    ProjectUserDisplayPropertyEndpoint,
+    BulkDeleteIssuesEndpoint,
+    DeletedIssuesListViewSet,
+    IssuePaginatedViewSet,
+    IssueDetailEndpoint,
+    IssueBulkUpdateDateEndpoint,
+    IssueMetaEndpoint,
+    IssueDetailIdentifierEndpoint,
+)
+
+from .issue.activity import IssueActivityEndpoint
+
+from .issue.archive import IssueArchiveViewSet, BulkArchiveIssuesEndpoint
+
+from .issue.attachment import (
+    IssueAttachmentEndpoint,
+    # V2
+    IssueAttachmentV2Endpoint,
+)
+
+from .issue.comment import IssueCommentViewSet, CommentReactionViewSet
+
+from .issue.label import LabelViewSet, BulkCreateIssueLabelsEndpoint
+
+from .issue.link import IssueLinkViewSet
+
+from .issue.relation import IssueRelationViewSet
+
+from .issue.reaction import IssueReactionViewSet
+
+from .issue.sub_issue import SubIssuesEndpoint
+
+from .issue.subscriber import IssueSubscriberViewSet
+
+from .issue.version import IssueVersionEndpoint, WorkItemDescriptionVersionEndpoint
+
+from .module.base import (
+    ModuleViewSet,
+    ModuleLinkViewSet,
+    ModuleFavoriteViewSet,
+    ModuleUserPropertiesEndpoint,
+)
+
+from .module.issue import ModuleIssueViewSet
+
+from .module.archive import ModuleArchiveUnarchiveEndpoint
+
+from .api import ApiTokenEndpoint
+
+from .page.base import (
+    PageViewSet,
+    PageFavoriteViewSet,
+    PagesDescriptionViewSet,
+    PageDuplicateEndpoint,
+)
+from .page.version import PageVersionEndpoint
+
+from .search.base import GlobalSearchEndpoint, SearchEndpoint
+from .search.issue import IssueSearchEndpoint
+
+
+from .external.base import (
+    GPTIntegrationEndpoint,
+    UnsplashEndpoint,
+    WorkspaceGPTIntegrationEndpoint,
+)
+from .estimate.base import (
+    ProjectEstimatePointEndpoint,
+    BulkEstimatePointEndpoint,
+    EstimatePointEndpoint,
+)
+
+from .intake.base import (
+    IntakeViewSet,
+    IntakeIssueViewSet,
+    IntakeWorkItemDescriptionVersionEndpoint,
+)
+
+from .analytic.base import (
+    AnalyticsEndpoint,
+    AnalyticViewViewset,
+    SavedAnalyticEndpoint,
+    ExportAnalyticsEndpoint,
+    DefaultAnalyticsEndpoint,
+    ProjectStatsEndpoint,
+)
+
+from .analytic.advance import (
+    AdvanceAnalyticsEndpoint,
+    AdvanceAnalyticsStatsEndpoint,
+    AdvanceAnalyticsChartEndpoint,
+)
+
+from .analytic.project_analytics import (
+    ProjectAdvanceAnalyticsEndpoint,
+    ProjectAdvanceAnalyticsStatsEndpoint,
+    ProjectAdvanceAnalyticsChartEndpoint,
+)
+
+from .notification.base import (
+    NotificationViewSet,
+    UnreadNotificationEndpoint,
+    UserNotificationPreferenceEndpoint,
+)
+
+from .exporter.base import ExportIssuesEndpoint
+
+
+from .webhook.base import (
+    WebhookEndpoint,
+    WebhookLogsEndpoint,
+    WebhookSecretRegenerateEndpoint,
+)
+
+from .error_404 import custom_404_view
+
+from .notification.base import MarkAllReadNotificationViewSet
+from .user.base import AccountEndpoint, ProfileEndpoint, UserSessionEndpoint
+
+from .timezone.base import TimezoneEndpoint

plane-src/apps/api/plane/app/views/analytic/advance.py

@@ -0,0 +1,318 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+from rest_framework.response import Response
+from rest_framework import status
+from typing import Dict, List, Any
+from django.db.models import QuerySet, Q, Count
+from django.http import HttpRequest
+from django.db.models.functions import TruncMonth
+from django.utils import timezone
+from plane.app.views.base import BaseAPIView
+from plane.app.permissions import ROLE, allow_permission
+from plane.db.models import (
+    WorkspaceMember,
+    Project,
+    Issue,
+    Cycle,
+    Module,
+    IssueView,
+    ProjectPage,
+    Workspace,
+    ProjectMember,
+)
+from plane.utils.build_chart import build_analytics_chart
+from plane.utils.date_utils import (
+    get_analytics_filters,
+)
+
+
+class AdvanceAnalyticsBaseView(BaseAPIView):
+    def initialize_workspace(self, slug: str, type: str) -> None:
+        self._workspace_slug = slug
+        self.filters = get_analytics_filters(
+            slug=slug,
+            type=type,
+            user=self.request.user,
+            date_filter=self.request.GET.get("date_filter", None),
+            project_ids=self.request.GET.get("project_ids", None),
+        )
+
+
+class AdvanceAnalyticsEndpoint(AdvanceAnalyticsBaseView):
+    def get_filtered_counts(self, queryset: QuerySet) -> Dict[str, int]:
+        def get_filtered_count() -> int:
+            if self.filters["analytics_date_range"]:
+                return queryset.filter(
+                    created_at__gte=self.filters["analytics_date_range"]["current"]["gte"],
+                    created_at__lte=self.filters["analytics_date_range"]["current"]["lte"],
+                ).count()
+            return queryset.count()
+
+        def get_previous_count() -> int:
+            if self.filters["analytics_date_range"] and self.filters["analytics_date_range"].get("previous"):
+                return queryset.filter(
+                    created_at__gte=self.filters["analytics_date_range"]["previous"]["gte"],
+                    created_at__lte=self.filters["analytics_date_range"]["previous"]["lte"],
+                ).count()
+            return 0
+
+        return {
+            "count": get_filtered_count(),
+            # "filter_count": get_previous_count(),
+        }
+
+    def get_overview_data(self) -> Dict[str, Dict[str, int]]:
+        members_query = WorkspaceMember.objects.filter(
+            workspace__slug=self._workspace_slug, is_active=True, member__is_bot=False
+        )
+
+        if self.request.GET.get("project_ids", None):
+            project_ids = self.request.GET.get("project_ids", None)
+            project_ids = [str(project_id) for project_id in project_ids.split(",")]
+            members_query = ProjectMember.objects.filter(
+                project_id__in=project_ids, is_active=True, member__is_bot=False
+            )
+
+        return {
+            "total_users": self.get_filtered_counts(members_query),
+            "total_admins": self.get_filtered_counts(members_query.filter(role=ROLE.ADMIN.value)),
+            "total_members": self.get_filtered_counts(members_query.filter(role=ROLE.MEMBER.value)),
+            "total_guests": self.get_filtered_counts(members_query.filter(role=ROLE.GUEST.value)),
+            "total_projects": self.get_filtered_counts(Project.objects.filter(**self.filters["project_filters"])),
+            "total_work_items": self.get_filtered_counts(Issue.issue_objects.filter(**self.filters["base_filters"])),
+            "total_cycles": self.get_filtered_counts(Cycle.objects.filter(**self.filters["base_filters"])),
+            "total_intake": self.get_filtered_counts(
+                Issue.objects.filter(**self.filters["base_filters"]).filter(
+                    issue_intake__status__in=["-2", "-1", "0", "1", "2"]  # TODO: Add description for reference.
+                )
+            ),
+        }
+
+    def get_work_items_stats(self) -> Dict[str, Dict[str, int]]:
+        base_queryset = Issue.issue_objects.filter(**self.filters["base_filters"])
+
+        return {
+            "total_work_items": self.get_filtered_counts(base_queryset),
+            "started_work_items": self.get_filtered_counts(base_queryset.filter(state__group="started")),
+            "backlog_work_items": self.get_filtered_counts(base_queryset.filter(state__group="backlog")),
+            "un_started_work_items": self.get_filtered_counts(base_queryset.filter(state__group="unstarted")),
+            "completed_work_items": self.get_filtered_counts(base_queryset.filter(state__group="completed")),
+        }
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER], level="WORKSPACE")
+    def get(self, request: HttpRequest, slug: str) -> Response:
+        self.initialize_workspace(slug, type="analytics")
+        tab = request.GET.get("tab", "overview")
+
+        if tab == "overview":
+            return Response(
+                self.get_overview_data(),
+                status=status.HTTP_200_OK,
+            )
+        elif tab == "work-items":
+            return Response(
+                self.get_work_items_stats(),
+                status=status.HTTP_200_OK,
+            )
+        return Response({"message": "Invalid tab"}, status=status.HTTP_400_BAD_REQUEST)
+
+
+class AdvanceAnalyticsStatsEndpoint(AdvanceAnalyticsBaseView):
+    def get_project_issues_stats(self) -> QuerySet:
+        # Get the base queryset with workspace and project filters
+        base_queryset = Issue.issue_objects.filter(**self.filters["base_filters"])
+
+        # Apply date range filter if available
+        if self.filters["chart_period_range"]:
+            start_date, end_date = self.filters["chart_period_range"]
+            base_queryset = base_queryset.filter(created_at__date__gte=start_date, created_at__date__lte=end_date)
+
+        return (
+            base_queryset.values("project_id", "project__name")
+            .annotate(
+                cancelled_work_items=Count("id", filter=Q(state__group="cancelled")),
+                completed_work_items=Count("id", filter=Q(state__group="completed")),
+                backlog_work_items=Count("id", filter=Q(state__group="backlog")),
+                un_started_work_items=Count("id", filter=Q(state__group="unstarted")),
+                started_work_items=Count("id", filter=Q(state__group="started")),
+            )
+            .order_by("project_id")
+        )
+
+    def get_work_items_stats(self) -> Dict[str, Dict[str, int]]:
+        base_queryset = Issue.issue_objects.filter(**self.filters["base_filters"])
+        return (
+            base_queryset.values("project_id", "project__name")
+            .annotate(
+                cancelled_work_items=Count("id", filter=Q(state__group="cancelled")),
+                completed_work_items=Count("id", filter=Q(state__group="completed")),
+                backlog_work_items=Count("id", filter=Q(state__group="backlog")),
+                un_started_work_items=Count("id", filter=Q(state__group="unstarted")),
+                started_work_items=Count("id", filter=Q(state__group="started")),
+            )
+            .order_by("project_id")
+        )
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER], level="WORKSPACE")
+    def get(self, request: HttpRequest, slug: str) -> Response:
+        self.initialize_workspace(slug, type="chart")
+        type = request.GET.get("type", "work-items")
+
+        if type == "work-items":
+            return Response(
+                self.get_work_items_stats(),
+                status=status.HTTP_200_OK,
+            )
+
+        return Response({"message": "Invalid type"}, status=status.HTTP_400_BAD_REQUEST)
+
+
+class AdvanceAnalyticsChartEndpoint(AdvanceAnalyticsBaseView):
+    def project_chart(self) -> List[Dict[str, Any]]:
+        # Get the base queryset with workspace and project filters
+        base_queryset = Issue.issue_objects.filter(**self.filters["base_filters"])
+        date_filter = {}
+
+        # Apply date range filter if available
+        if self.filters["chart_period_range"]:
+            start_date, end_date = self.filters["chart_period_range"]
+            date_filter = {
+                "created_at__date__gte": start_date,
+                "created_at__date__lte": end_date,
+            }
+
+        total_work_items = base_queryset.filter(**date_filter).count()
+        total_cycles = Cycle.objects.filter(**self.filters["base_filters"], **date_filter).count()
+        total_modules = Module.objects.filter(**self.filters["base_filters"], **date_filter).count()
+        total_intake = Issue.objects.filter(
+            issue_intake__isnull=False, **self.filters["base_filters"], **date_filter
+        ).count()
+        total_members = WorkspaceMember.objects.filter(
+            workspace__slug=self._workspace_slug, is_active=True, **date_filter
+        ).count()
+        total_pages = ProjectPage.objects.filter(**self.filters["base_filters"], **date_filter).count()
+        total_views = IssueView.objects.filter(**self.filters["base_filters"], **date_filter).count()
+
+        data = {
+            "work_items": total_work_items,
+            "cycles": total_cycles,
+            "modules": total_modules,
+            "intake": total_intake,
+            "members": total_members,
+            "pages": total_pages,
+            "views": total_views,
+        }
+
+        return [
+            {
+                "key": key,
+                "name": key.replace("_", " ").title(),
+                "count": value or 0,
+            }
+            for key, value in data.items()
+        ]
+
+    def work_item_completion_chart(self) -> Dict[str, Any]:
+        # Get the base queryset
+        queryset = (
+            Issue.issue_objects.filter(**self.filters["base_filters"])
+            .select_related("workspace", "state", "parent")
+            .prefetch_related("assignees", "labels", "issue_module__module", "issue_cycle__cycle")
+        )
+
+        workspace = Workspace.objects.get(slug=self._workspace_slug)
+        start_date = workspace.created_at.date().replace(day=1)
+
+        # Apply date range filter if available
+        if self.filters["chart_period_range"]:
+            start_date, end_date = self.filters["chart_period_range"]
+            queryset = queryset.filter(created_at__date__gte=start_date, created_at__date__lte=end_date)
+
+        # Annotate by month and count
+        monthly_stats = (
+            queryset.annotate(month=TruncMonth("created_at"))
+            .values("month")
+            .annotate(
+                created_count=Count("id"),
+                completed_count=Count("id", filter=Q(state__group="completed")),
+            )
+            .order_by("month")
+        )
+
+        # Create dictionary of month -> counts
+        stats_dict = {
+            stat["month"].strftime("%Y-%m-%d"): {
+                "created_count": stat["created_count"],
+                "completed_count": stat["completed_count"],
+            }
+            for stat in monthly_stats
+        }
+
+        # Generate monthly data (ensure months with 0 count are included)
+        data = []
+        # include the current date at the end
+        end_date = timezone.now().date()
+        last_month = end_date.replace(day=1)
+        current_month = start_date
+
+        while current_month <= last_month:
+            date_str = current_month.strftime("%Y-%m-%d")
+            stats = stats_dict.get(date_str, {"created_count": 0, "completed_count": 0})
+            data.append(
+                {
+                    "key": date_str,
+                    "name": date_str,
+                    "count": stats["created_count"],
+                    "completed_issues": stats["completed_count"],
+                    "created_issues": stats["created_count"],
+                }
+            )
+            # Move to next month
+            if current_month.month == 12:
+                current_month = current_month.replace(year=current_month.year + 1, month=1)
+            else:
+                current_month = current_month.replace(month=current_month.month + 1)
+
+        schema = {
+            "completed_issues": "completed_issues",
+            "created_issues": "created_issues",
+        }
+
+        return {"data": data, "schema": schema}
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER], level="WORKSPACE")
+    def get(self, request: HttpRequest, slug: str) -> Response:
+        self.initialize_workspace(slug, type="chart")
+        type = request.GET.get("type", "projects")
+        group_by = request.GET.get("group_by", None)
+        x_axis = request.GET.get("x_axis", "PRIORITY")
+
+        if type == "projects":
+            return Response(self.project_chart(), status=status.HTTP_200_OK)
+
+        elif type == "custom-work-items":
+            queryset = (
+                Issue.issue_objects.filter(**self.filters["base_filters"])
+                .select_related("workspace", "state", "parent")
+                .prefetch_related("assignees", "labels", "issue_module__module", "issue_cycle__cycle")
+            )
+
+            # Apply date range filter if available
+            if self.filters["chart_period_range"]:
+                start_date, end_date = self.filters["chart_period_range"]
+                queryset = queryset.filter(created_at__date__gte=start_date, created_at__date__lte=end_date)
+
+            return Response(
+                build_analytics_chart(queryset, x_axis, group_by),
+                status=status.HTTP_200_OK,
+            )
+
+        elif type == "work-items":
+            return Response(
+                self.work_item_completion_chart(),
+                status=status.HTTP_200_OK,
+            )
+
+        return Response({"message": "Invalid type"}, status=status.HTTP_400_BAD_REQUEST)

plane-src/apps/api/plane/app/views/analytic/base.py

@@ -0,0 +1,482 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+# Django imports
+from django.db.models import Count, F, Sum, Q
+from django.db.models.functions import ExtractMonth
+from django.utils import timezone
+from django.db.models.functions import Concat
+from django.db.models import Case, When, Value, OuterRef, Func
+from django.db import models
+
+# Third party imports
+from rest_framework import status
+from rest_framework.response import Response
+
+# Module imports
+from plane.app.permissions import WorkSpaceAdminPermission
+from plane.app.serializers import AnalyticViewSerializer
+from plane.app.views.base import BaseAPIView, BaseViewSet
+from plane.bgtasks.analytic_plot_export import analytic_export_task
+from plane.db.models import (
+    AnalyticView,
+    Issue,
+    Workspace,
+    Project,
+    ProjectMember,
+    Cycle,
+    Module,
+)
+
+from plane.utils.analytics_plot import build_graph_plot
+from plane.utils.issue_filters import issue_filters
+from plane.app.permissions import allow_permission, ROLE
+
+
+class AnalyticsEndpoint(BaseAPIView):
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER], level="WORKSPACE")
+    def get(self, request, slug):
+        x_axis = request.GET.get("x_axis", False)
+        y_axis = request.GET.get("y_axis", False)
+        segment = request.GET.get("segment", False)
+
+        valid_xaxis_segment = [
+            "state_id",
+            "state__group",
+            "labels__id",
+            "assignees__id",
+            "estimate_point__value",
+            "issue_cycle__cycle_id",
+            "issue_module__module_id",
+            "priority",
+            "start_date",
+            "target_date",
+            "created_at",
+            "completed_at",
+        ]
+
+        valid_yaxis = ["issue_count", "estimate"]
+
+        # Check for x-axis and y-axis as thery are required parameters
+        if not x_axis or not y_axis or x_axis not in valid_xaxis_segment or y_axis not in valid_yaxis:
+            return Response(
+                {"error": "x-axis and y-axis dimensions are required and the values should be valid"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # If segment is present it cannot be same as x-axis
+        if segment and (segment not in valid_xaxis_segment or x_axis == segment):
+            return Response(
+                {"error": "Both segment and x axis cannot be same and segment should be valid"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # Additional filters that need to be applied
+        filters = issue_filters(request.GET, "GET")
+
+        # Get the issues for the workspace with the additional filters applied
+        queryset = Issue.issue_objects.filter(workspace__slug=slug, **filters)
+
+        # Get the total issue count
+        total_issues = queryset.count()
+
+        # Build the graph payload
+        distribution = build_graph_plot(queryset=queryset, x_axis=x_axis, y_axis=y_axis, segment=segment)
+
+        state_details = {}
+        if x_axis in ["state_id"] or segment in ["state_id"]:
+            state_details = (
+                Issue.issue_objects.filter(workspace__slug=slug, **filters)
+                .distinct("state_id")
+                .order_by("state_id")
+                .values("state_id", "state__name", "state__color")
+            )
+
+        label_details = {}
+        if x_axis in ["labels__id"] or segment in ["labels__id"]:
+            label_details = (
+                Issue.objects.filter(
+                    workspace__slug=slug,
+                    **filters,
+                    labels__id__isnull=False,
+                    label_issue__deleted_at__isnull=True,
+                )
+                .distinct("labels__id")
+                .order_by("labels__id")
+                .values("labels__id", "labels__color", "labels__name")
+            )
+
+        assignee_details = {}
+        if x_axis in ["assignees__id"] or segment in ["assignees__id"]:
+            assignee_details = (
+                Issue.issue_objects.filter(
+                    Q(Q(assignees__avatar__isnull=False) | Q(assignees__avatar_asset__isnull=False)),
+                    workspace__slug=slug,
+                    **filters,
+                )
+                .annotate(
+                    assignees__avatar_url=Case(
+                        # If `avatar_asset` exists, use it to generate the asset URL
+                        When(
+                            assignees__avatar_asset__isnull=False,
+                            then=Concat(
+                                Value("/api/assets/v2/static/"),
+                                "assignees__avatar_asset",  # Assuming avatar_asset has an id or relevant field
+                                Value("/"),
+                            ),
+                        ),
+                        # If `avatar_asset` is None, fall back to using `avatar` field directly
+                        When(
+                            assignees__avatar_asset__isnull=True,
+                            then="assignees__avatar",
+                        ),
+                        default=Value(None),
+                        output_field=models.CharField(),
+                    )
+                )
+                .order_by("assignees__id")
+                .distinct("assignees__id")
+                .values(
+                    "assignees__avatar_url",
+                    "assignees__display_name",
+                    "assignees__first_name",
+                    "assignees__last_name",
+                    "assignees__id",
+                )
+            )
+
+        cycle_details = {}
+        if x_axis in ["issue_cycle__cycle_id"] or segment in ["issue_cycle__cycle_id"]:
+            cycle_details = (
+                Issue.issue_objects.filter(
+                    workspace__slug=slug,
+                    **filters,
+                    issue_cycle__cycle_id__isnull=False,
+                    issue_cycle__deleted_at__isnull=True,
+                )
+                .distinct("issue_cycle__cycle_id")
+                .order_by("issue_cycle__cycle_id")
+                .values("issue_cycle__cycle_id", "issue_cycle__cycle__name")
+            )
+
+        module_details = {}
+        if x_axis in ["issue_module__module_id"] or segment in ["issue_module__module_id"]:
+            module_details = (
+                Issue.issue_objects.filter(
+                    workspace__slug=slug,
+                    **filters,
+                    issue_module__module_id__isnull=False,
+                    issue_module__deleted_at__isnull=True,
+                )
+                .distinct("issue_module__module_id")
+                .order_by("issue_module__module_id")
+                .values("issue_module__module_id", "issue_module__module__name")
+            )
+
+        return Response(
+            {
+                "total": total_issues,
+                "distribution": distribution,
+                "extras": {
+                    "state_details": state_details,
+                    "assignee_details": assignee_details,
+                    "label_details": label_details,
+                    "cycle_details": cycle_details,
+                    "module_details": module_details,
+                },
+            },
+            status=status.HTTP_200_OK,
+        )
+
+
+class AnalyticViewViewset(BaseViewSet):
+    permission_classes = [WorkSpaceAdminPermission]
+    model = AnalyticView
+    serializer_class = AnalyticViewSerializer
+
+    def perform_create(self, serializer):
+        workspace = Workspace.objects.get(slug=self.kwargs.get("slug"))
+        serializer.save(workspace_id=workspace.id)
+
+    def get_queryset(self):
+        return self.filter_queryset(super().get_queryset().filter(workspace__slug=self.kwargs.get("slug")))
+
+
+class SavedAnalyticEndpoint(BaseAPIView):
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER], level="WORKSPACE")
+    def get(self, request, slug, analytic_id):
+        analytic_view = AnalyticView.objects.get(pk=analytic_id, workspace__slug=slug)
+
+        filter = analytic_view.query
+        queryset = Issue.issue_objects.filter(**filter)
+
+        x_axis = analytic_view.query_dict.get("x_axis", False)
+        y_axis = analytic_view.query_dict.get("y_axis", False)
+
+        if not x_axis or not y_axis:
+            return Response(
+                {"error": "x-axis and y-axis dimensions are required"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        segment = request.GET.get("segment", False)
+        distribution = build_graph_plot(queryset=queryset, x_axis=x_axis, y_axis=y_axis, segment=segment)
+        total_issues = queryset.count()
+        return Response(
+            {"total": total_issues, "distribution": distribution},
+            status=status.HTTP_200_OK,
+        )
+
+
+class ExportAnalyticsEndpoint(BaseAPIView):
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER], level="WORKSPACE")
+    def post(self, request, slug):
+        x_axis = request.data.get("x_axis", False)
+        y_axis = request.data.get("y_axis", False)
+        segment = request.data.get("segment", False)
+
+        valid_xaxis_segment = [
+            "state_id",
+            "state__group",
+            "labels__id",
+            "assignees__id",
+            "estimate_point",
+            "issue_cycle__cycle_id",
+            "issue_module__module_id",
+            "priority",
+            "start_date",
+            "target_date",
+            "created_at",
+            "completed_at",
+        ]
+
+        valid_yaxis = ["issue_count", "estimate"]
+
+        # Check for x-axis and y-axis as thery are required parameters
+        if not x_axis or not y_axis or x_axis not in valid_xaxis_segment or y_axis not in valid_yaxis:
+            return Response(
+                {"error": "x-axis and y-axis dimensions are required and the values should be valid"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # If segment is present it cannot be same as x-axis
+        if segment and (segment not in valid_xaxis_segment or x_axis == segment):
+            return Response(
+                {"error": "Both segment and x axis cannot be same and segment should be valid"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        analytic_export_task.delay(email=request.user.email, data=request.data, slug=slug)
+
+        return Response(
+            {"message": f"Once the export is ready it will be emailed to you at {str(request.user.email)}"},
+            status=status.HTTP_200_OK,
+        )
+
+
+class DefaultAnalyticsEndpoint(BaseAPIView):
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], level="WORKSPACE")
+    def get(self, request, slug):
+        filters = issue_filters(request.GET, "GET")
+        base_issues = Issue.issue_objects.filter(workspace__slug=slug, **filters)
+
+        total_issues = base_issues.count()
+
+        state_groups = base_issues.annotate(state_group=F("state__group"))
+
+        total_issues_classified = (
+            state_groups.values("state_group").annotate(state_count=Count("state_group")).order_by("state_group")
+        )
+
+        open_issues_groups = ["backlog", "unstarted", "started"]
+        open_issues_queryset = state_groups.filter(state__group__in=open_issues_groups)
+
+        open_issues = open_issues_queryset.count()
+        open_issues_classified = (
+            open_issues_queryset.values("state_group")
+            .annotate(state_count=Count("state_group"))
+            .order_by("state_group")
+        )
+
+        current_year = timezone.now().year
+        issue_completed_month_wise = (
+            base_issues.filter(completed_at__year=current_year)
+            .annotate(month=ExtractMonth("completed_at"))
+            .values("month")
+            .annotate(count=Count("*"))
+            .order_by("month")
+        )
+
+        user_details = [
+            "created_by__first_name",
+            "created_by__last_name",
+            "created_by__display_name",
+            "created_by__id",
+        ]
+
+        most_issue_created_user = (
+            base_issues.exclude(created_by=None)
+            .values(*user_details)
+            .annotate(count=Count("id"))
+            .annotate(
+                created_by__avatar_url=Case(
+                    # If `avatar_asset` exists, use it to generate the asset URL
+                    When(
+                        created_by__avatar_asset__isnull=False,
+                        then=Concat(
+                            Value("/api/assets/v2/static/"),
+                            "created_by__avatar_asset",  # Assuming avatar_asset has an id or relevant field
+                            Value("/"),
+                        ),
+                    ),
+                    # If `avatar_asset` is None, fall back to using `avatar` field directly
+                    When(created_by__avatar_asset__isnull=True, then="created_by__avatar"),
+                    default=Value(None),
+                    output_field=models.CharField(),
+                )
+            )
+            .order_by("-count")[:5]
+        )
+
+        user_assignee_details = [
+            "assignees__first_name",
+            "assignees__last_name",
+            "assignees__display_name",
+            "assignees__id",
+        ]
+
+        most_issue_closed_user = (
+            base_issues.filter(completed_at__isnull=False)
+            .exclude(assignees=None)
+            .values(*user_assignee_details)
+            .annotate(
+                assignees__avatar_url=Case(
+                    # If `avatar_asset` exists, use it to generate the asset URL
+                    When(
+                        assignees__avatar_asset__isnull=False,
+                        then=Concat(
+                            Value("/api/assets/v2/static/"),
+                            "assignees__avatar_asset",  # Assuming avatar_asset has an id or relevant field
+                            Value("/"),
+                        ),
+                    ),
+                    # If `avatar_asset` is None, fall back to using `avatar` field directly
+                    When(assignees__avatar_asset__isnull=True, then="assignees__avatar"),
+                    default=Value(None),
+                    output_field=models.CharField(),
+                )
+            )
+            .annotate(count=Count("id"))
+            .order_by("-count")[:5]
+        )
+
+        pending_issue_user = (
+            base_issues.filter(completed_at__isnull=True)
+            .values(*user_assignee_details)
+            .annotate(count=Count("id"))
+            .annotate(
+                assignees__avatar_url=Case(
+                    # If `avatar_asset` exists, use it to generate the asset URL
+                    When(
+                        assignees__avatar_asset__isnull=False,
+                        then=Concat(
+                            Value("/api/assets/v2/static/"),
+                            "assignees__avatar_asset",  # Assuming avatar_asset has an id or relevant field
+                            Value("/"),
+                        ),
+                    ),
+                    # If `avatar_asset` is None, fall back to using `avatar` field directly
+                    When(assignees__avatar_asset__isnull=True, then="assignees__avatar"),
+                    default=Value(None),
+                    output_field=models.CharField(),
+                )
+            )
+            .order_by("-count")
+        )
+
+        open_estimate_sum = open_issues_queryset.aggregate(sum=Sum("point"))["sum"]
+        total_estimate_sum = base_issues.aggregate(sum=Sum("point"))["sum"]
+
+        return Response(
+            {
+                "total_issues": total_issues,
+                "total_issues_classified": total_issues_classified,
+                "open_issues": open_issues,
+                "open_issues_classified": open_issues_classified,
+                "issue_completed_month_wise": issue_completed_month_wise,
+                "most_issue_created_user": most_issue_created_user,
+                "most_issue_closed_user": most_issue_closed_user,
+                "pending_issue_user": pending_issue_user,
+                "open_estimate_sum": open_estimate_sum,
+                "total_estimate_sum": total_estimate_sum,
+            },
+            status=status.HTTP_200_OK,
+        )
+
+
+class ProjectStatsEndpoint(BaseAPIView):
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], level="WORKSPACE")
+    def get(self, request, slug):
+        fields = request.GET.get("fields", "").split(",")
+        project_ids = request.GET.get("project_ids", "")
+
+        valid_fields = {
+            "total_issues",
+            "completed_issues",
+            "total_members",
+            "total_cycles",
+            "total_modules",
+        }
+        requested_fields = set(filter(None, fields)) & valid_fields
+
+        if not requested_fields:
+            requested_fields = valid_fields
+
+        projects = Project.objects.filter(workspace__slug=slug)
+        if project_ids:
+            projects = projects.filter(id__in=project_ids.split(","))
+
+        annotations = {}
+        if "total_issues" in requested_fields:
+            annotations["total_issues"] = (
+                Issue.issue_objects.filter(project_id=OuterRef("pk"))
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
+
+        if "completed_issues" in requested_fields:
+            annotations["completed_issues"] = (
+                Issue.issue_objects.filter(project_id=OuterRef("pk"), state__group__in=["completed", "cancelled"])
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
+
+        if "total_cycles" in requested_fields:
+            annotations["total_cycles"] = (
+                Cycle.objects.filter(project_id=OuterRef("id"))
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
+
+        if "total_modules" in requested_fields:
+            annotations["total_modules"] = (
+                Module.objects.filter(project_id=OuterRef("id"))
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
+
+        if "total_members" in requested_fields:
+            annotations["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")
+            )
+
+        projects = projects.annotate(**annotations).values("id", *requested_fields)
+        return Response(projects, status=status.HTTP_200_OK)

plane-src/apps/api/plane/app/views/analytic/project_analytics.py

@@ -0,0 +1,367 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+from rest_framework.response import Response
+from rest_framework import status
+from typing import Dict, Any
+from django.db.models import QuerySet, Q, Count
+from django.http import HttpRequest
+from django.db.models.functions import TruncMonth
+from django.utils import timezone
+from datetime import timedelta
+from plane.app.views.base import BaseAPIView
+from plane.app.permissions import ROLE, allow_permission
+from plane.db.models import (
+    Project,
+    Issue,
+    Cycle,
+    Module,
+    CycleIssue,
+    ModuleIssue,
+)
+from django.db import models
+from django.db.models import F, Case, When, Value
+from django.db.models.functions import Concat
+from plane.utils.build_chart import build_analytics_chart
+from plane.utils.date_utils import (
+    get_analytics_filters,
+)
+
+
+class ProjectAdvanceAnalyticsBaseView(BaseAPIView):
+    def initialize_workspace(self, slug: str, type: str) -> None:
+        self._workspace_slug = slug
+        self.filters = get_analytics_filters(
+            slug=slug,
+            type=type,
+            user=self.request.user,
+            date_filter=self.request.GET.get("date_filter", None),
+            project_ids=self.request.GET.get("project_ids", None),
+        )
+
+
+class ProjectAdvanceAnalyticsEndpoint(ProjectAdvanceAnalyticsBaseView):
+    def get_filtered_counts(self, queryset: QuerySet) -> Dict[str, int]:
+        def get_filtered_count() -> int:
+            if self.filters["analytics_date_range"]:
+                return queryset.filter(
+                    created_at__gte=self.filters["analytics_date_range"]["current"]["gte"],
+                    created_at__lte=self.filters["analytics_date_range"]["current"]["lte"],
+                ).count()
+            return queryset.count()
+
+        return {
+            "count": get_filtered_count(),
+        }
+
+    def get_work_items_stats(self, project_id, cycle_id=None, module_id=None) -> Dict[str, Dict[str, int]]:
+        """
+        Returns work item stats for the workspace, or filtered by cycle_id or module_id if provided.
+        """
+        base_queryset = None
+        if cycle_id is not None:
+            cycle_issues = CycleIssue.objects.filter(**self.filters["base_filters"], cycle_id=cycle_id).values_list(
+                "issue_id", flat=True
+            )
+            base_queryset = Issue.issue_objects.filter(id__in=cycle_issues)
+        elif module_id is not None:
+            module_issues = ModuleIssue.objects.filter(**self.filters["base_filters"], module_id=module_id).values_list(
+                "issue_id", flat=True
+            )
+            base_queryset = Issue.issue_objects.filter(id__in=module_issues)
+        else:
+            base_queryset = Issue.issue_objects.filter(**self.filters["base_filters"], project_id=project_id)
+
+        return {
+            "total_work_items": self.get_filtered_counts(base_queryset),
+            "started_work_items": self.get_filtered_counts(base_queryset.filter(state__group="started")),
+            "backlog_work_items": self.get_filtered_counts(base_queryset.filter(state__group="backlog")),
+            "un_started_work_items": self.get_filtered_counts(base_queryset.filter(state__group="unstarted")),
+            "completed_work_items": self.get_filtered_counts(base_queryset.filter(state__group="completed")),
+        }
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
+    def get(self, request: HttpRequest, slug: str, project_id: str) -> Response:
+        self.initialize_workspace(slug, type="analytics")
+
+        # Optionally accept cycle_id or module_id as query params
+        cycle_id = request.GET.get("cycle_id", None)
+        module_id = request.GET.get("module_id", None)
+        return Response(
+            self.get_work_items_stats(cycle_id=cycle_id, module_id=module_id, project_id=project_id),
+            status=status.HTTP_200_OK,
+        )
+
+
+class ProjectAdvanceAnalyticsStatsEndpoint(ProjectAdvanceAnalyticsBaseView):
+    def get_project_issues_stats(self) -> QuerySet:
+        # Get the base queryset with workspace and project filters
+        base_queryset = Issue.issue_objects.filter(**self.filters["base_filters"])
+
+        # Apply date range filter if available
+        if self.filters["chart_period_range"]:
+            start_date, end_date = self.filters["chart_period_range"]
+            base_queryset = base_queryset.filter(created_at__date__gte=start_date, created_at__date__lte=end_date)
+
+        return (
+            base_queryset.values("project_id", "project__name")
+            .annotate(
+                cancelled_work_items=Count("id", filter=Q(state__group="cancelled")),
+                completed_work_items=Count("id", filter=Q(state__group="completed")),
+                backlog_work_items=Count("id", filter=Q(state__group="backlog")),
+                un_started_work_items=Count("id", filter=Q(state__group="unstarted")),
+                started_work_items=Count("id", filter=Q(state__group="started")),
+            )
+            .order_by("project_id")
+        )
+
+    def get_work_items_stats(self, project_id, cycle_id=None, module_id=None) -> Dict[str, Dict[str, int]]:
+        base_queryset = None
+        if cycle_id is not None:
+            cycle_issues = CycleIssue.objects.filter(**self.filters["base_filters"], cycle_id=cycle_id).values_list(
+                "issue_id", flat=True
+            )
+            base_queryset = Issue.issue_objects.filter(id__in=cycle_issues)
+        elif module_id is not None:
+            module_issues = ModuleIssue.objects.filter(**self.filters["base_filters"], module_id=module_id).values_list(
+                "issue_id", flat=True
+            )
+            base_queryset = Issue.issue_objects.filter(id__in=module_issues)
+        else:
+            base_queryset = Issue.issue_objects.filter(**self.filters["base_filters"], project_id=project_id)
+        return (
+            base_queryset.annotate(display_name=F("assignees__display_name"))
+            .annotate(assignee_id=F("assignees__id"))
+            .annotate(avatar=F("assignees__avatar"))
+            .annotate(
+                avatar_url=Case(
+                    # If `avatar_asset` exists, use it to generate the asset URL
+                    When(
+                        assignees__avatar_asset__isnull=False,
+                        then=Concat(
+                            Value("/api/assets/v2/static/"),
+                            "assignees__avatar_asset",  # Assuming avatar_asset has an id or relevant field
+                            Value("/"),
+                        ),
+                    ),
+                    # If `avatar_asset` is None, fall back to using `avatar` field directly
+                    When(assignees__avatar_asset__isnull=True, then="assignees__avatar"),
+                    default=Value(None),
+                    output_field=models.CharField(),
+                )
+            )
+            .values("display_name", "assignee_id", "avatar_url")
+            .annotate(
+                cancelled_work_items=Count("id", filter=Q(state__group="cancelled"), distinct=True),
+                completed_work_items=Count("id", filter=Q(state__group="completed"), distinct=True),
+                backlog_work_items=Count("id", filter=Q(state__group="backlog"), distinct=True),
+                un_started_work_items=Count("id", filter=Q(state__group="unstarted"), distinct=True),
+                started_work_items=Count("id", filter=Q(state__group="started"), distinct=True),
+            )
+            .order_by("display_name")
+        )
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
+    def get(self, request: HttpRequest, slug: str, project_id: str) -> Response:
+        self.initialize_workspace(slug, type="chart")
+        type = request.GET.get("type", "work-items")
+
+        if type == "work-items":
+            # Optionally accept cycle_id or module_id as query params
+            cycle_id = request.GET.get("cycle_id", None)
+            module_id = request.GET.get("module_id", None)
+            return Response(
+                self.get_work_items_stats(project_id=project_id, cycle_id=cycle_id, module_id=module_id),
+                status=status.HTTP_200_OK,
+            )
+
+        return Response({"message": "Invalid type"}, status=status.HTTP_400_BAD_REQUEST)
+
+
+class ProjectAdvanceAnalyticsChartEndpoint(ProjectAdvanceAnalyticsBaseView):
+    def work_item_completion_chart(self, project_id, cycle_id=None, module_id=None) -> Dict[str, Any]:
+        # Get the base queryset
+        queryset = (
+            Issue.issue_objects.filter(**self.filters["base_filters"])
+            .filter(project_id=project_id)
+            .select_related("workspace", "state", "parent")
+            .prefetch_related("assignees", "labels", "issue_module__module", "issue_cycle__cycle")
+        )
+
+        if cycle_id is not None:
+            cycle_issues = CycleIssue.objects.filter(**self.filters["base_filters"], cycle_id=cycle_id).values_list(
+                "issue_id", flat=True
+            )
+            cycle = Cycle.objects.filter(id=cycle_id).first()
+            if cycle and cycle.start_date:
+                start_date = cycle.start_date.date()
+                end_date = cycle.end_date.date()
+            else:
+                return {"data": [], "schema": {}}
+            queryset = cycle_issues
+
+        elif module_id is not None:
+            module_issues = ModuleIssue.objects.filter(**self.filters["base_filters"], module_id=module_id).values_list(
+                "issue_id", flat=True
+            )
+            module = Module.objects.filter(id=module_id).first()
+            if module and module.start_date:
+                start_date = module.start_date
+                end_date = module.target_date
+            else:
+                return {"data": [], "schema": {}}
+            queryset = module_issues
+
+        else:
+            project = Project.objects.filter(id=project_id).first()
+            if project.created_at:
+                start_date = project.created_at.date().replace(day=1)
+            else:
+                return {"data": [], "schema": {}}
+
+        if cycle_id or module_id:
+            # Get daily stats with optimized query
+            daily_stats = (
+                queryset.values("created_at__date")
+                .annotate(
+                    created_count=Count("id"),
+                    completed_count=Count("id", filter=Q(issue__state__group="completed")),
+                )
+                .order_by("created_at__date")
+            )
+
+            # Create a dictionary of existing stats with summed counts
+            stats_dict = {
+                stat["created_at__date"].strftime("%Y-%m-%d"): {
+                    "created_count": stat["created_count"],
+                    "completed_count": stat["completed_count"],
+                }
+                for stat in daily_stats
+            }
+
+            # Generate data for all days in the range
+            data = []
+            current_date = start_date
+            while current_date <= end_date:
+                date_str = current_date.strftime("%Y-%m-%d")
+                stats = stats_dict.get(date_str, {"created_count": 0, "completed_count": 0})
+                data.append(
+                    {
+                        "key": date_str,
+                        "name": date_str,
+                        "count": stats["created_count"] + stats["completed_count"],
+                        "completed_issues": stats["completed_count"],
+                        "created_issues": stats["created_count"],
+                    }
+                )
+                current_date += timedelta(days=1)
+        else:
+            # Apply date range filter if available
+            if self.filters["chart_period_range"]:
+                start_date, end_date = self.filters["chart_period_range"]
+                queryset = queryset.filter(created_at__date__gte=start_date, created_at__date__lte=end_date)
+
+            # Annotate by month and count
+            monthly_stats = (
+                queryset.annotate(month=TruncMonth("created_at"))
+                .values("month")
+                .annotate(
+                    created_count=Count("id"),
+                    completed_count=Count("id", filter=Q(state__group="completed")),
+                )
+                .order_by("month")
+            )
+
+            # Create dictionary of month -> counts
+            stats_dict = {
+                stat["month"].strftime("%Y-%m-%d"): {
+                    "created_count": stat["created_count"],
+                    "completed_count": stat["completed_count"],
+                }
+                for stat in monthly_stats
+            }
+
+            # Generate monthly data (ensure months with 0 count are included)
+            data = []
+            # include the current date at the end
+            end_date = timezone.now().date()
+            last_month = end_date.replace(day=1)
+            current_month = start_date
+
+            while current_month <= last_month:
+                date_str = current_month.strftime("%Y-%m-%d")
+                stats = stats_dict.get(date_str, {"created_count": 0, "completed_count": 0})
+                data.append(
+                    {
+                        "key": date_str,
+                        "name": date_str,
+                        "count": stats["created_count"],
+                        "completed_issues": stats["completed_count"],
+                        "created_issues": stats["created_count"],
+                    }
+                )
+                # Move to next month
+                if current_month.month == 12:
+                    current_month = current_month.replace(year=current_month.year + 1, month=1)
+                else:
+                    current_month = current_month.replace(month=current_month.month + 1)
+
+        schema = {
+            "completed_issues": "completed_issues",
+            "created_issues": "created_issues",
+        }
+
+        return {"data": data, "schema": schema}
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
+    def get(self, request: HttpRequest, slug: str, project_id: str) -> Response:
+        self.initialize_workspace(slug, type="chart")
+        type = request.GET.get("type", "projects")
+        group_by = request.GET.get("group_by", None)
+        x_axis = request.GET.get("x_axis", "PRIORITY")
+        cycle_id = request.GET.get("cycle_id", None)
+        module_id = request.GET.get("module_id", None)
+
+        if type == "custom-work-items":
+            queryset = (
+                Issue.issue_objects.filter(**self.filters["base_filters"])
+                .filter(project_id=project_id)
+                .select_related("workspace", "state", "parent")
+                .prefetch_related("assignees", "labels", "issue_module__module", "issue_cycle__cycle")
+            )
+
+            # Apply cycle/module filters if present
+            if cycle_id is not None:
+                cycle_issues = CycleIssue.objects.filter(**self.filters["base_filters"], cycle_id=cycle_id).values_list(
+                    "issue_id", flat=True
+                )
+                queryset = queryset.filter(id__in=cycle_issues)
+
+            elif module_id is not None:
+                module_issues = ModuleIssue.objects.filter(
+                    **self.filters["base_filters"], module_id=module_id
+                ).values_list("issue_id", flat=True)
+                queryset = queryset.filter(id__in=module_issues)
+
+            # Apply date range filter if available
+            if self.filters["chart_period_range"]:
+                start_date, end_date = self.filters["chart_period_range"]
+                queryset = queryset.filter(created_at__date__gte=start_date, created_at__date__lte=end_date)
+
+            return Response(
+                build_analytics_chart(queryset, x_axis, group_by),
+                status=status.HTTP_200_OK,
+            )
+
+        elif type == "work-items":
+            # Optionally accept cycle_id or module_id as query params
+            cycle_id = request.GET.get("cycle_id", None)
+            module_id = request.GET.get("module_id", None)
+
+            return Response(
+                self.work_item_completion_chart(project_id=project_id, cycle_id=cycle_id, module_id=module_id),
+                status=status.HTTP_200_OK,
+            )
+
+        return Response({"message": "Invalid type"}, status=status.HTTP_400_BAD_REQUEST)

plane-src/apps/api/plane/app/views/api.py

@@ -0,0 +1,62 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+# Python import
+from uuid import uuid4
+from typing import Optional
+
+# Third party
+from rest_framework.response import Response
+from rest_framework.request import Request
+from rest_framework import status
+
+# Module import
+from .base import BaseAPIView
+from plane.db.models import APIToken
+from plane.app.serializers import APITokenSerializer, APITokenReadSerializer
+
+
+class ApiTokenEndpoint(BaseAPIView):
+    def post(self, request: Request) -> Response:
+        label = request.data.get("label", str(uuid4().hex))
+        description = request.data.get("description", "")
+        expired_at = request.data.get("expired_at", None)
+
+        # Check the user type
+        user_type = 1 if request.user.is_bot else 0
+
+        api_token = APIToken.objects.create(
+            label=label,
+            description=description,
+            user=request.user,
+            user_type=user_type,
+            expired_at=expired_at,
+        )
+
+        serializer = APITokenSerializer(api_token)
+        # Token will be only visible while creating
+        return Response(serializer.data, status=status.HTTP_201_CREATED)
+
+    def get(self, request: Request, pk: Optional[str] = None) -> Response:
+        if pk is None:
+            api_tokens = APIToken.objects.filter(user=request.user, is_service=False)
+            serializer = APITokenReadSerializer(api_tokens, many=True)
+            return Response(serializer.data, status=status.HTTP_200_OK)
+        else:
+            api_tokens = APIToken.objects.get(user=request.user, pk=pk)
+            serializer = APITokenReadSerializer(api_tokens)
+            return Response(serializer.data, status=status.HTTP_200_OK)
+
+    def delete(self, request: Request, pk: str) -> Response:
+        api_token = APIToken.objects.get(user=request.user, pk=pk, is_service=False)
+        api_token.delete()
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+    def patch(self, request: Request, pk: str) -> Response:
+        api_token = APIToken.objects.get(user=request.user, pk=pk)
+        serializer = APITokenSerializer(api_token, data=request.data, partial=True)
+        if serializer.is_valid():
+            serializer.save()
+            return Response(serializer.data, status=status.HTTP_200_OK)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

plane-src/apps/api/plane/app/views/asset/base.py

@@ -0,0 +1,86 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+# Third party imports
+from rest_framework import status
+from rest_framework.response import Response
+from rest_framework.parsers import MultiPartParser, FormParser, JSONParser
+
+# Module imports
+from ..base import BaseAPIView, BaseViewSet
+from plane.db.models import FileAsset, Workspace
+from plane.app.serializers import FileAssetSerializer
+
+
+class FileAssetEndpoint(BaseAPIView):
+    parser_classes = (MultiPartParser, FormParser, JSONParser)
+
+    """
+    A viewset for viewing and editing task instances.
+    """
+
+    def get(self, request, workspace_id, asset_key):
+        asset_key = str(workspace_id) + "/" + asset_key
+        files = FileAsset.objects.filter(asset=asset_key)
+        if files.exists():
+            serializer = FileAssetSerializer(files, context={"request": request}, many=True)
+            return Response({"data": serializer.data, "status": True}, status=status.HTTP_200_OK)
+        else:
+            return Response(
+                {"error": "Asset key does not exist", "status": False},
+                status=status.HTTP_200_OK,
+            )
+
+    def post(self, request, slug):
+        serializer = FileAssetSerializer(data=request.data)
+        if serializer.is_valid():
+            # Get the workspace
+            workspace = Workspace.objects.get(slug=slug)
+            serializer.save(workspace_id=workspace.id)
+            return Response(serializer.data, status=status.HTTP_201_CREATED)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    def delete(self, request, workspace_id, asset_key):
+        asset_key = str(workspace_id) + "/" + asset_key
+        file_asset = FileAsset.objects.get(asset=asset_key)
+        file_asset.is_deleted = True
+        file_asset.save(update_fields=["is_deleted"])
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+class FileAssetViewSet(BaseViewSet):
+    def restore(self, request, workspace_id, asset_key):
+        asset_key = str(workspace_id) + "/" + asset_key
+        file_asset = FileAsset.objects.get(asset=asset_key)
+        file_asset.is_deleted = False
+        file_asset.save(update_fields=["is_deleted"])
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+class UserAssetsEndpoint(BaseAPIView):
+    parser_classes = (MultiPartParser, FormParser)
+
+    def get(self, request, asset_key):
+        files = FileAsset.objects.filter(asset=asset_key, created_by=request.user)
+        if files.exists():
+            serializer = FileAssetSerializer(files, context={"request": request})
+            return Response({"data": serializer.data, "status": True}, status=status.HTTP_200_OK)
+        else:
+            return Response(
+                {"error": "Asset key does not exist", "status": False},
+                status=status.HTTP_200_OK,
+            )
+
+    def post(self, request):
+        serializer = FileAssetSerializer(data=request.data)
+        if serializer.is_valid():
+            serializer.save()
+            return Response(serializer.data, status=status.HTTP_201_CREATED)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    def delete(self, request, asset_key):
+        file_asset = FileAsset.objects.get(asset=asset_key, created_by=request.user)
+        file_asset.is_deleted = True
+        file_asset.save(update_fields=["is_deleted"])
+        return Response(status=status.HTTP_204_NO_CONTENT)

plane-src/apps/api/plane/app/views/asset/v2.py

@@ -0,0 +1,835 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+# Python imports
+import uuid
+
+# Django imports
+from django.conf import settings
+from django.http import HttpResponseRedirect
+from django.utils import timezone
+from django.db import IntegrityError
+
+# Third party imports
+from rest_framework import status
+from rest_framework.response import Response
+from rest_framework.permissions import AllowAny
+
+# Module imports
+from ..base import BaseAPIView
+from plane.db.models import FileAsset, Workspace, Project, User
+from plane.settings.storage import S3Storage
+from plane.app.permissions import allow_permission, ROLE
+from plane.utils.cache import invalidate_cache_directly
+from plane.bgtasks.storage_metadata_task import get_asset_object_metadata
+from plane.throttles.asset import AssetRateThrottle
+
+
+class UserAssetsV2Endpoint(BaseAPIView):
+    """This endpoint is used to upload user profile images."""
+
+    def asset_delete(self, asset_id):
+        asset = FileAsset.objects.filter(id=asset_id).first()
+        if asset is None:
+            return
+        asset.is_deleted = True
+        asset.deleted_at = timezone.now()
+        asset.save(update_fields=["is_deleted", "deleted_at"])
+        return
+
+    def entity_asset_save(self, asset_id, entity_type, asset, request):
+        # User Avatar
+        if entity_type == FileAsset.EntityTypeContext.USER_AVATAR:
+            user = User.objects.get(id=asset.user_id)
+            user.avatar = ""
+            # Delete the previous avatar
+            if user.avatar_asset_id:
+                self.asset_delete(user.avatar_asset_id)
+            # Save the new avatar
+            user.avatar_asset_id = asset_id
+            user.save()
+            invalidate_cache_directly(path="/api/users/me/", url_params=False, user=True, request=request)
+            invalidate_cache_directly(
+                path="/api/users/me/settings/",
+                url_params=False,
+                user=True,
+                request=request,
+            )
+            return
+        # User Cover
+        if entity_type == FileAsset.EntityTypeContext.USER_COVER:
+            user = User.objects.get(id=asset.user_id)
+            user.cover_image = None
+            # Delete the previous cover image
+            if user.cover_image_asset_id:
+                self.asset_delete(user.cover_image_asset_id)
+            # Save the new cover image
+            user.cover_image_asset_id = asset_id
+            user.save()
+            invalidate_cache_directly(path="/api/users/me/", url_params=False, user=True, request=request)
+            invalidate_cache_directly(
+                path="/api/users/me/settings/",
+                url_params=False,
+                user=True,
+                request=request,
+            )
+            return
+        return
+
+    def entity_asset_delete(self, entity_type, asset, request):
+        # User Avatar
+        if entity_type == FileAsset.EntityTypeContext.USER_AVATAR:
+            user = User.objects.get(id=asset.user_id)
+            user.avatar_asset_id = None
+            user.save()
+            invalidate_cache_directly(path="/api/users/me/", url_params=False, user=True, request=request)
+            invalidate_cache_directly(
+                path="/api/users/me/settings/",
+                url_params=False,
+                user=True,
+                request=request,
+            )
+            return
+        # User Cover
+        if entity_type == FileAsset.EntityTypeContext.USER_COVER:
+            user = User.objects.get(id=asset.user_id)
+            user.cover_image_asset_id = None
+            user.save()
+            invalidate_cache_directly(path="/api/users/me/", url_params=False, user=True, request=request)
+            invalidate_cache_directly(
+                path="/api/users/me/settings/",
+                url_params=False,
+                user=True,
+                request=request,
+            )
+            return
+        return
+
+    def post(self, request):
+        # get the asset key
+        name = request.data.get("name")
+        type = request.data.get("type", "image/jpeg")
+        size = int(request.data.get("size", settings.FILE_SIZE_LIMIT))
+        entity_type = request.data.get("entity_type", False)
+
+        # Check if the file size is within the limit
+        size_limit = min(size, settings.FILE_SIZE_LIMIT)
+
+        #  Check if the entity type is allowed
+        if not entity_type or entity_type not in ["USER_AVATAR", "USER_COVER"]:
+            return Response(
+                {"error": "Invalid entity type.", "status": False},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # Check if the file type is allowed
+        allowed_types = [
+            "image/jpeg",
+            "image/png",
+            "image/webp",
+            "image/jpg",
+            "image/gif",
+        ]
+        if type not in allowed_types:
+            return Response(
+                {
+                    "error": "Invalid file type. Only JPEG, PNG, WebP, JPG and GIF files are allowed.",
+                    "status": False,
+                },
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # asset key
+        asset_key = f"{uuid.uuid4().hex}-{name}"
+
+        # Create a File Asset
+        asset = FileAsset.objects.create(
+            attributes={"name": name, "type": type, "size": size_limit},
+            asset=asset_key,
+            size=size_limit,
+            user=request.user,
+            created_by=request.user,
+            entity_type=entity_type,
+        )
+
+        # Get the presigned URL
+        storage = S3Storage(request=request)
+        # Generate a presigned URL to share an S3 object
+        presigned_url = storage.generate_presigned_post(object_name=asset_key, file_type=type, file_size=size_limit)
+        # Return the presigned URL
+        return Response(
+            {
+                "upload_data": presigned_url,
+                "asset_id": str(asset.id),
+                "asset_url": asset.asset_url,
+            },
+            status=status.HTTP_200_OK,
+        )
+
+    def patch(self, request, asset_id):
+        # get the asset id
+        asset = FileAsset.objects.get(id=asset_id, user_id=request.user.id)
+        # get the storage metadata
+        asset.is_uploaded = True
+        # get the storage metadata
+        if not asset.storage_metadata:
+            get_asset_object_metadata.delay(asset_id=str(asset_id))
+        # get the entity and save the asset id for the request field
+        self.entity_asset_save(
+            asset_id=asset_id,
+            entity_type=asset.entity_type,
+            asset=asset,
+            request=request,
+        )
+        # update the attributes
+        asset.attributes = request.data.get("attributes", asset.attributes)
+        # save the asset
+        asset.save(update_fields=["is_uploaded", "attributes"])
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+    def delete(self, request, asset_id):
+        asset = FileAsset.objects.get(id=asset_id, user_id=request.user.id)
+        asset.is_deleted = True
+        asset.deleted_at = timezone.now()
+        # get the entity and save the asset id for the request field
+        self.entity_asset_delete(entity_type=asset.entity_type, asset=asset, request=request)
+        asset.save(update_fields=["is_deleted", "deleted_at"])
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+class WorkspaceFileAssetEndpoint(BaseAPIView):
+    """This endpoint is used to upload cover images/logos etc for workspace, projects and users."""
+
+    def get_entity_id_field(self, entity_type, entity_id):
+        # Workspace Logo
+        if entity_type == FileAsset.EntityTypeContext.WORKSPACE_LOGO:
+            return {"workspace_id": entity_id}
+
+        # Project Cover
+        if entity_type == FileAsset.EntityTypeContext.PROJECT_COVER:
+            return {"project_id": entity_id}
+
+        # User Avatar and Cover
+        if entity_type in [
+            FileAsset.EntityTypeContext.USER_AVATAR,
+            FileAsset.EntityTypeContext.USER_COVER,
+        ]:
+            return {"user_id": entity_id}
+
+        # Issue Attachment and Description
+        if entity_type in [
+            FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
+            FileAsset.EntityTypeContext.ISSUE_DESCRIPTION,
+        ]:
+            return {"issue_id": entity_id}
+
+        # Page Description
+        if entity_type == FileAsset.EntityTypeContext.PAGE_DESCRIPTION:
+            return {"page_id": entity_id}
+
+        # Comment Description
+        if entity_type == FileAsset.EntityTypeContext.COMMENT_DESCRIPTION:
+            return {"comment_id": entity_id}
+        return {}
+
+    def asset_delete(self, asset_id):
+        asset = FileAsset.objects.filter(id=asset_id).first()
+        # Check if the asset exists
+        if asset is None:
+            return
+        # Mark the asset as deleted
+        asset.is_deleted = True
+        asset.deleted_at = timezone.now()
+        asset.save(update_fields=["is_deleted", "deleted_at"])
+        return
+
+    def entity_asset_save(self, asset_id, entity_type, asset, request):
+        # Workspace Logo
+        if entity_type == FileAsset.EntityTypeContext.WORKSPACE_LOGO:
+            workspace = Workspace.objects.filter(id=asset.workspace_id).first()
+            if workspace is None:
+                return
+            # Delete the previous logo
+            if workspace.logo_asset_id:
+                self.asset_delete(workspace.logo_asset_id)
+            # Save the new logo
+            workspace.logo = ""
+            workspace.logo_asset_id = asset_id
+            workspace.save()
+            invalidate_cache_directly(path="/api/workspaces/", url_params=False, user=False, request=request)
+            invalidate_cache_directly(
+                path="/api/users/me/workspaces/",
+                url_params=False,
+                user=True,
+                request=request,
+            )
+            invalidate_cache_directly(path="/api/instances/", url_params=False, user=False, request=request)
+            return
+
+        # Project Cover
+        elif entity_type == FileAsset.EntityTypeContext.PROJECT_COVER:
+            project = Project.objects.filter(id=asset.project_id).first()
+            if project is None:
+                return
+            # Delete the previous cover image
+            if project.cover_image_asset_id:
+                self.asset_delete(project.cover_image_asset_id)
+            # Save the new cover image
+            project.cover_image = ""
+            project.cover_image_asset_id = asset_id
+            project.save()
+            return
+        else:
+            return
+
+    def entity_asset_delete(self, entity_type, asset, request):
+        # Workspace Logo
+        if entity_type == FileAsset.EntityTypeContext.WORKSPACE_LOGO:
+            workspace = Workspace.objects.get(id=asset.workspace_id)
+            if workspace is None:
+                return
+            workspace.logo_asset_id = None
+            workspace.save()
+            invalidate_cache_directly(path="/api/workspaces/", url_params=False, user=False, request=request)
+            invalidate_cache_directly(
+                path="/api/users/me/workspaces/",
+                url_params=False,
+                user=True,
+                request=request,
+            )
+            invalidate_cache_directly(path="/api/instances/", url_params=False, user=False, request=request)
+            return
+        # Project Cover
+        elif entity_type == FileAsset.EntityTypeContext.PROJECT_COVER:
+            project = Project.objects.filter(id=asset.project_id).first()
+            if project is None:
+                return
+            project.cover_image_asset_id = None
+            project.save()
+            return
+        else:
+            return
+
+    def post(self, request, slug):
+        name = request.data.get("name")
+        type = request.data.get("type", "image/jpeg")
+        size = int(request.data.get("size", settings.FILE_SIZE_LIMIT))
+        entity_type = request.data.get("entity_type")
+        entity_identifier = request.data.get("entity_identifier", False)
+
+        # Check if the entity type is allowed
+        if entity_type not in FileAsset.EntityTypeContext.values:
+            return Response(
+                {"error": "Invalid entity type.", "status": False},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # Check if the file type is allowed
+        allowed_types = [
+            "image/jpeg",
+            "image/png",
+            "image/webp",
+            "image/jpg",
+            "image/gif",
+        ]
+        if type not in allowed_types:
+            return Response(
+                {
+                    "error": "Invalid file type. Only JPEG, PNG, WebP, JPG and GIF files are allowed.",
+                    "status": False,
+                },
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # Get the size limit
+        size_limit = min(settings.FILE_SIZE_LIMIT, size)
+
+        # Get the workspace
+        workspace = Workspace.objects.get(slug=slug)
+
+        # asset key
+        asset_key = f"{workspace.id}/{uuid.uuid4().hex}-{name}"
+
+        # Create a File Asset
+        asset = FileAsset.objects.create(
+            attributes={"name": name, "type": type, "size": size_limit},
+            asset=asset_key,
+            size=size_limit,
+            workspace=workspace,
+            created_by=request.user,
+            entity_type=entity_type,
+            **self.get_entity_id_field(entity_type=entity_type, entity_id=entity_identifier),
+        )
+
+        # Get the presigned URL
+        storage = S3Storage(request=request)
+        # Generate a presigned URL to share an S3 object
+        presigned_url = storage.generate_presigned_post(object_name=asset_key, file_type=type, file_size=size_limit)
+        # Return the presigned URL
+        return Response(
+            {
+                "upload_data": presigned_url,
+                "asset_id": str(asset.id),
+                "asset_url": asset.asset_url,
+            },
+            status=status.HTTP_200_OK,
+        )
+
+    def patch(self, request, slug, asset_id):
+        # get the asset id
+        asset = FileAsset.objects.get(id=asset_id, workspace__slug=slug)
+        # get the storage metadata
+        asset.is_uploaded = True
+        # get the storage metadata
+        if not asset.storage_metadata:
+            get_asset_object_metadata.delay(asset_id=str(asset_id))
+        # get the entity and save the asset id for the request field
+        self.entity_asset_save(
+            asset_id=asset_id,
+            entity_type=asset.entity_type,
+            asset=asset,
+            request=request,
+        )
+        # update the attributes
+        asset.attributes = request.data.get("attributes", asset.attributes)
+        # save the asset
+        asset.save(update_fields=["is_uploaded", "attributes"])
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+    def delete(self, request, slug, asset_id):
+        asset = FileAsset.objects.get(id=asset_id, workspace__slug=slug)
+        asset.is_deleted = True
+        asset.deleted_at = timezone.now()
+        # get the entity and save the asset id for the request field
+        self.entity_asset_delete(entity_type=asset.entity_type, asset=asset, request=request)
+        asset.save(update_fields=["is_deleted", "deleted_at"])
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+    def get(self, request, slug, asset_id):
+        # get the asset id
+        asset = FileAsset.objects.get(id=asset_id, workspace__slug=slug)
+
+        # Check if the asset is uploaded
+        if not asset.is_uploaded:
+            return Response(
+                {"error": "The requested asset could not be found."},
+                status=status.HTTP_404_NOT_FOUND,
+            )
+
+        # Get the presigned URL
+        storage = S3Storage(request=request)
+        # Generate a presigned URL to share an S3 object
+        signed_url = storage.generate_presigned_url(
+            object_name=asset.asset.name,
+            disposition="attachment",
+            filename=asset.attributes.get("name"),
+        )
+        # Redirect to the signed URL
+        return HttpResponseRedirect(signed_url)
+
+
+class StaticFileAssetEndpoint(BaseAPIView):
+    """This endpoint is used to get the signed URL for a static asset."""
+
+    permission_classes = [AllowAny]
+
+    def get(self, request, asset_id):
+        # get the asset id
+        asset = FileAsset.objects.get(id=asset_id)
+
+        # Check if the asset is uploaded
+        if not asset.is_uploaded:
+            return Response(
+                {"error": "The requested asset could not be found."},
+                status=status.HTTP_404_NOT_FOUND,
+            )
+
+        # Check if the entity type is allowed
+        if asset.entity_type not in [
+            FileAsset.EntityTypeContext.USER_AVATAR,
+            FileAsset.EntityTypeContext.USER_COVER,
+            FileAsset.EntityTypeContext.WORKSPACE_LOGO,
+            FileAsset.EntityTypeContext.PROJECT_COVER,
+        ]:
+            return Response(
+                {"error": "Invalid entity type.", "status": False},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # Get the presigned URL
+        storage = S3Storage(request=request)
+        # Generate a presigned URL to share an S3 object
+        signed_url = storage.generate_presigned_url(object_name=asset.asset.name)
+        # Redirect to the signed URL
+        return HttpResponseRedirect(signed_url)
+
+
+class AssetRestoreEndpoint(BaseAPIView):
+    """Endpoint to restore a deleted assets."""
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], level="WORKSPACE")
+    def post(self, request, slug, asset_id):
+        asset = FileAsset.all_objects.get(id=asset_id, workspace__slug=slug)
+        asset.is_deleted = False
+        asset.deleted_at = None
+        asset.save(update_fields=["is_deleted", "deleted_at"])
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+class ProjectAssetEndpoint(BaseAPIView):
+    """This endpoint is used to upload cover images/logos etc for workspace, projects and users."""
+
+    def get_entity_id_field(self, entity_type, entity_id):
+        if entity_type == FileAsset.EntityTypeContext.WORKSPACE_LOGO:
+            return {"workspace_id": entity_id}
+
+        if entity_type == FileAsset.EntityTypeContext.PROJECT_COVER:
+            return {"project_id": entity_id}
+
+        if entity_type in [
+            FileAsset.EntityTypeContext.USER_AVATAR,
+            FileAsset.EntityTypeContext.USER_COVER,
+        ]:
+            return {"user_id": entity_id}
+
+        if entity_type in [
+            FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
+            FileAsset.EntityTypeContext.ISSUE_DESCRIPTION,
+        ]:
+            return {"issue_id": entity_id}
+
+        if entity_type == FileAsset.EntityTypeContext.PAGE_DESCRIPTION:
+            return {"page_id": entity_id}
+
+        if entity_type == FileAsset.EntityTypeContext.COMMENT_DESCRIPTION:
+            return {"comment_id": entity_id}
+
+        if entity_type == FileAsset.EntityTypeContext.DRAFT_ISSUE_DESCRIPTION:
+            return {"draft_issue_id": entity_id}
+        return {}
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
+    def post(self, request, slug, project_id):
+        name = request.data.get("name")
+        type = request.data.get("type", "image/jpeg")
+        size = int(request.data.get("size", settings.FILE_SIZE_LIMIT))
+        entity_type = request.data.get("entity_type", "")
+        entity_identifier = request.data.get("entity_identifier")
+
+        # Check if the entity type is allowed
+        if entity_type not in FileAsset.EntityTypeContext.values:
+            return Response(
+                {"error": "Invalid entity type.", "status": False},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # Check if the file type is allowed
+        allowed_types = [
+            "image/jpeg",
+            "image/png",
+            "image/webp",
+            "image/jpg",
+            "image/gif",
+        ]
+        if type not in allowed_types:
+            return Response(
+                {
+                    "error": "Invalid file type. Only JPEG, PNG, WebP, JPG and GIF files are allowed.",
+                    "status": False,
+                },
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # Get the size limit
+        size_limit = min(settings.FILE_SIZE_LIMIT, size)
+
+        # Get the workspace
+        workspace = Workspace.objects.get(slug=slug)
+
+        # asset key
+        asset_key = f"{workspace.id}/{uuid.uuid4().hex}-{name}"
+
+        # Create a File Asset
+        asset = FileAsset.objects.create(
+            attributes={"name": name, "type": type, "size": size_limit},
+            asset=asset_key,
+            size=size_limit,
+            workspace=workspace,
+            created_by=request.user,
+            entity_type=entity_type,
+            project_id=project_id,
+            **self.get_entity_id_field(entity_type, entity_identifier),
+        )
+
+        # Get the presigned URL
+        storage = S3Storage(request=request)
+        # Generate a presigned URL to share an S3 object
+        presigned_url = storage.generate_presigned_post(object_name=asset_key, file_type=type, file_size=size_limit)
+        # Return the presigned URL
+        return Response(
+            {
+                "upload_data": presigned_url,
+                "asset_id": str(asset.id),
+                "asset_url": asset.asset_url,
+            },
+            status=status.HTTP_200_OK,
+        )
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
+    def patch(self, request, slug, project_id, pk):
+        # get the asset id
+        asset = FileAsset.objects.get(id=pk, workspace__slug=slug, project_id=project_id)
+        # get the storage metadata
+        asset.is_uploaded = True
+        # get the storage metadata
+        if not asset.storage_metadata:
+            get_asset_object_metadata.delay(asset_id=str(pk))
+
+        # update the attributes
+        asset.attributes = request.data.get("attributes", asset.attributes)
+        # save the asset
+        asset.save(update_fields=["is_uploaded", "attributes"])
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
+    def delete(self, request, slug, project_id, pk):
+        # Get the asset
+        asset = FileAsset.objects.get(id=pk, workspace__slug=slug, project_id=project_id)
+        # Check deleted assets
+        asset.is_deleted = True
+        asset.deleted_at = timezone.now()
+        # Save the asset
+        asset.save(update_fields=["is_deleted", "deleted_at"])
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
+    def get(self, request, slug, project_id, pk):
+        # get the asset id
+        asset = FileAsset.objects.get(workspace__slug=slug, project_id=project_id, pk=pk)
+
+        # Check if the asset is uploaded
+        if not asset.is_uploaded:
+            return Response(
+                {"error": "The requested asset could not be found."},
+                status=status.HTTP_404_NOT_FOUND,
+            )
+
+        # Get the presigned URL
+        storage = S3Storage(request=request)
+        # Generate a presigned URL to share an S3 object
+        signed_url = storage.generate_presigned_url(
+            object_name=asset.asset.name,
+            disposition="attachment",
+            filename=asset.attributes.get("name"),
+        )
+        # Redirect to the signed URL
+        return HttpResponseRedirect(signed_url)
+
+
+class ProjectBulkAssetEndpoint(BaseAPIView):
+    def save_project_cover(self, asset, project_id):
+        project = Project.objects.get(id=project_id)
+        project.cover_image_asset_id = asset.id
+        project.save()
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
+    def post(self, request, slug, project_id, entity_id):
+        asset_ids = request.data.get("asset_ids", [])
+
+        # Check if the asset ids are provided
+        if not asset_ids:
+            return Response({"error": "No asset ids provided."}, status=status.HTTP_400_BAD_REQUEST)
+
+        # get the asset id
+        assets = FileAsset.objects.filter(id__in=asset_ids, workspace__slug=slug)
+
+        # Get the first asset
+        asset = assets.first()
+
+        if not asset:
+            return Response(
+                {"error": "The requested asset could not be found."},
+                status=status.HTTP_404_NOT_FOUND,
+            )
+
+        # Check if the asset is uploaded
+        if asset.entity_type == FileAsset.EntityTypeContext.PROJECT_COVER:
+            assets.update(project_id=project_id)
+            [self.save_project_cover(asset, project_id) for asset in assets]
+
+        if asset.entity_type == FileAsset.EntityTypeContext.ISSUE_DESCRIPTION:
+            # For some cases, the bulk api is called after the issue is deleted creating
+            # an integrity error
+            try:
+                assets.update(issue_id=entity_id, project_id=project_id)
+            except IntegrityError:
+                pass
+
+        if asset.entity_type == FileAsset.EntityTypeContext.COMMENT_DESCRIPTION:
+            # For some cases, the bulk api is called after the comment is deleted
+            # creating an integrity error
+            try:
+                assets.update(comment_id=entity_id)
+            except IntegrityError:
+                pass
+
+        if asset.entity_type == FileAsset.EntityTypeContext.PAGE_DESCRIPTION:
+            assets.update(page_id=entity_id)
+
+        if asset.entity_type == FileAsset.EntityTypeContext.DRAFT_ISSUE_DESCRIPTION:
+            # For some cases, the bulk api is called after the draft issue is deleted
+            # creating an integrity error
+            try:
+                assets.update(draft_issue_id=entity_id)
+            except IntegrityError:
+                pass
+
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+class AssetCheckEndpoint(BaseAPIView):
+    """Endpoint to check if an asset exists."""
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], level="WORKSPACE")
+    def get(self, request, slug, asset_id):
+        asset = FileAsset.all_objects.filter(id=asset_id, workspace__slug=slug, deleted_at__isnull=True).exists()
+        return Response({"exists": asset}, status=status.HTTP_200_OK)
+
+
+class DuplicateAssetEndpoint(BaseAPIView):
+    throttle_classes = [AssetRateThrottle]
+
+    def get_entity_id_field(self, entity_type, entity_id):
+        # Workspace Logo
+        if entity_type == FileAsset.EntityTypeContext.WORKSPACE_LOGO:
+            return {"workspace_id": entity_id}
+
+        # Project Cover
+        if entity_type == FileAsset.EntityTypeContext.PROJECT_COVER:
+            return {"project_id": entity_id}
+
+        # User Avatar and Cover
+        if entity_type in [
+            FileAsset.EntityTypeContext.USER_AVATAR,
+            FileAsset.EntityTypeContext.USER_COVER,
+        ]:
+            return {"user_id": entity_id}
+
+        # Issue Attachment and Description
+        if entity_type in [
+            FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
+            FileAsset.EntityTypeContext.ISSUE_DESCRIPTION,
+        ]:
+            return {"issue_id": entity_id}
+
+        # Page Description
+        if entity_type == FileAsset.EntityTypeContext.PAGE_DESCRIPTION:
+            return {"page_id": entity_id}
+
+        # Comment Description
+        if entity_type == FileAsset.EntityTypeContext.COMMENT_DESCRIPTION:
+            return {"comment_id": entity_id}
+
+        return {}
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], level="WORKSPACE")
+    def post(self, request, slug, asset_id):
+        project_id = request.data.get("project_id", None)
+        entity_id = request.data.get("entity_id", None)
+        entity_type = request.data.get("entity_type", None)
+
+        if not entity_type or entity_type not in FileAsset.EntityTypeContext.values:
+            return Response(
+                {"error": "Invalid entity type or entity id"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        workspace = Workspace.objects.get(slug=slug)
+        if project_id:
+            # check if project exists in the workspace
+            if not Project.objects.filter(id=project_id, workspace=workspace).exists():
+                return Response({"error": "Project not found"}, status=status.HTTP_404_NOT_FOUND)
+
+        storage = S3Storage(request=request)
+        original_asset = FileAsset.objects.filter(id=asset_id, is_uploaded=True).first()
+
+        if not original_asset:
+            return Response({"error": "Asset not found"}, status=status.HTTP_404_NOT_FOUND)
+
+        destination_key = f"{workspace.id}/{uuid.uuid4().hex}-{original_asset.attributes.get('name')}"
+        duplicated_asset = FileAsset.objects.create(
+            attributes={
+                "name": original_asset.attributes.get("name"),
+                "type": original_asset.attributes.get("type"),
+                "size": original_asset.attributes.get("size"),
+            },
+            asset=destination_key,
+            size=original_asset.size,
+            workspace=workspace,
+            created_by_id=request.user.id,
+            entity_type=entity_type,
+            project_id=project_id if project_id else None,
+            storage_metadata=original_asset.storage_metadata,
+            **self.get_entity_id_field(entity_type=entity_type, entity_id=entity_id),
+        )
+        storage.copy_object(original_asset.asset, destination_key)
+        # Update the is_uploaded field for all newly created assets
+        FileAsset.objects.filter(id=duplicated_asset.id).update(is_uploaded=True)
+
+        return Response({"asset_id": str(duplicated_asset.id)}, status=status.HTTP_200_OK)
+
+
+class WorkspaceAssetDownloadEndpoint(BaseAPIView):
+    """Endpoint to generate a download link for an asset with content-disposition=attachment."""
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], level="WORKSPACE")
+    def get(self, request, slug, asset_id):
+        try:
+            asset = FileAsset.objects.get(
+                id=asset_id,
+                workspace__slug=slug,
+                is_uploaded=True,
+            )
+        except FileAsset.DoesNotExist:
+            return Response(
+                {"error": "The requested asset could not be found."},
+                status=status.HTTP_404_NOT_FOUND,
+            )
+
+        storage = S3Storage(request=request)
+        signed_url = storage.generate_presigned_url(
+            object_name=asset.asset.name,
+            disposition="attachment",
+            filename=asset.attributes.get("name", uuid.uuid4().hex),
+        )
+
+        return HttpResponseRedirect(signed_url)
+
+
+class ProjectAssetDownloadEndpoint(BaseAPIView):
+    """Endpoint to generate a download link for an asset with content-disposition=attachment."""
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], level="PROJECT")
+    def get(self, request, slug, project_id, asset_id):
+        try:
+            asset = FileAsset.objects.get(
+                id=asset_id,
+                workspace__slug=slug,
+                project_id=project_id,
+                is_uploaded=True,
+            )
+        except FileAsset.DoesNotExist:
+            return Response(
+                {"error": "The requested asset could not be found."},
+                status=status.HTTP_404_NOT_FOUND,
+            )
+
+        storage = S3Storage(request=request)
+        signed_url = storage.generate_presigned_url(
+            object_name=asset.asset.name,
+            disposition="attachment",
+            filename=asset.attributes.get("name", uuid.uuid4().hex),
+        )
+
+        return HttpResponseRedirect(signed_url)

plane-src/apps/api/plane/app/views/base.py

@@ -0,0 +1,236 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+# Python imports
+import traceback
+
+import zoneinfo
+from django.conf import settings
+from django.core.exceptions import ObjectDoesNotExist, ValidationError
+from django.db import IntegrityError
+
+# Django imports
+from django.urls import resolve
+from django.utils import timezone
+from django_filters.rest_framework import DjangoFilterBackend
+
+# Third part imports
+from rest_framework import status
+from rest_framework.exceptions import APIException
+from rest_framework.filters import SearchFilter
+from rest_framework.permissions import IsAuthenticated
+from rest_framework.response import Response
+from rest_framework.views import APIView
+from rest_framework.viewsets import ModelViewSet
+
+# Module imports
+from plane.authentication.session import BaseSessionAuthentication
+from plane.utils.exception_logger import log_exception
+from plane.utils.paginator import BasePaginator
+from plane.utils.core.mixins import ReadReplicaControlMixin
+
+
+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 BaseViewSet(TimezoneMixin, ReadReplicaControlMixin, ModelViewSet, BasePaginator):
+    model = None
+
+    permission_classes = [IsAuthenticated]
+
+    filter_backends = (DjangoFilterBackend, SearchFilter)
+
+    authentication_classes = [BaseSessionAuthentication]
+
+    filterset_fields = []
+
+    search_fields = []
+
+    use_read_replica = False
+
+    def get_queryset(self):
+        try:
+            return self.model.objects.all()
+        except Exception as e:
+            log_exception(e)
+            raise APIException("Please check the view", status.HTTP_400_BAD_REQUEST)
+
+    def handle_exception(self, exc):
+        """
+        Handle any exception that occurs, by returning an appropriate response,
+        or re-raising the error.
+        """
+        try:
+            response = super().handle_exception(exc)
+            return response
+        except Exception as e:
+            (print(e, traceback.format_exc()) if settings.DEBUG else print("Server Error"))
+            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 required object does not exist."},
+                    status=status.HTTP_404_NOT_FOUND,
+                )
+
+            if isinstance(e, KeyError):
+                log_exception(e)
+                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
+
+    @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
+
+
+class BaseAPIView(TimezoneMixin, ReadReplicaControlMixin, APIView, BasePaginator):
+    permission_classes = [IsAuthenticated]
+
+    filter_backends = (DjangoFilterBackend, SearchFilter)
+
+    authentication_classes = [BaseSessionAuthentication]
+
+    filterset_fields = []
+
+    search_fields = []
+
+    use_read_replica = False
+
+    def filter_queryset(self, queryset):
+        for backend in list(self.filter_backends):
+            queryset = backend().filter_queryset(self.request, queryset, self)
+        return queryset
+
+    def handle_exception(self, exc):
+        """
+        Handle any exception that occurs, by returning an appropriate response,
+        or re-raising the error.
+        """
+        try:
+            response = super().handle_exception(exc)
+            return response
+        except Exception as e:
+            if isinstance(e, IntegrityError):
+                return Response(
+                    {"error": "The payload is not valid"},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+            if isinstance(e, ValidationError):
+                return Response(
+                    {"error": "Please provide valid detail"},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+            if isinstance(e, ObjectDoesNotExist):
+                return Response(
+                    {"error": "The required object 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
+
+    @property
+    def workspace_slug(self):
+        return self.kwargs.get("slug", None)
+
+    @property
+    def project_id(self):
+        return self.kwargs.get("project_id", None)
+
+    @property
+    def fields(self):
+        fields = [field for field in self.request.GET.get("fields", "").split(",") if field]
+        return fields if fields else None
+
+    @property
+    def expand(self):
+        expand = [expand for expand in self.request.GET.get("expand", "").split(",") if expand]
+        return expand if expand else None

plane-src/apps/api/plane/app/views/cycle/archive.py

@@ -0,0 +1,611 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+# Django imports
+from django.contrib.postgres.aggregates import ArrayAgg
+from django.contrib.postgres.fields import ArrayField
+from django.db import models
+from django.db.models import (
+    Case,
+    CharField,
+    Count,
+    Exists,
+    F,
+    Func,
+    OuterRef,
+    Prefetch,
+    Q,
+    UUIDField,
+    Value,
+    When,
+    Subquery,
+    Sum,
+    FloatField,
+)
+from django.db.models.functions import Coalesce, Cast, Concat
+from django.utils import timezone
+
+# Third party imports
+from rest_framework import status
+from rest_framework.response import Response
+from plane.app.permissions import allow_permission, ROLE
+from plane.db.models import Cycle, UserFavorite, Issue, Label, User, Project
+from plane.utils.analytics_plot import burndown_plot
+
+# Module imports
+from .. import BaseAPIView
+
+
+class CycleArchiveUnarchiveEndpoint(BaseAPIView):
+    def get_queryset(self):
+        favorite_subquery = UserFavorite.objects.filter(
+            user=self.request.user,
+            entity_type="cycle",
+            entity_identifier=OuterRef("pk"),
+            project_id=self.kwargs.get("project_id"),
+            workspace__slug=self.kwargs.get("slug"),
+        )
+        backlog_estimate_point = (
+            Issue.issue_objects.filter(
+                estimate_point__estimate__type="points",
+                state__group="backlog",
+                issue_cycle__cycle_id=OuterRef("pk"),
+                issue_cycle__deleted_at__isnull=True,
+            )
+            .values("issue_cycle__cycle_id")
+            .annotate(backlog_estimate_point=Sum(Cast("estimate_point__value", FloatField())))
+            .values("backlog_estimate_point")[:1]
+        )
+        unstarted_estimate_point = (
+            Issue.issue_objects.filter(
+                estimate_point__estimate__type="points",
+                state__group="unstarted",
+                issue_cycle__cycle_id=OuterRef("pk"),
+                issue_cycle__deleted_at__isnull=True,
+            )
+            .values("issue_cycle__cycle_id")
+            .annotate(unstarted_estimate_point=Sum(Cast("estimate_point__value", FloatField())))
+            .values("unstarted_estimate_point")[:1]
+        )
+        started_estimate_point = (
+            Issue.issue_objects.filter(
+                estimate_point__estimate__type="points",
+                state__group="started",
+                issue_cycle__cycle_id=OuterRef("pk"),
+                issue_cycle__deleted_at__isnull=True,
+            )
+            .values("issue_cycle__cycle_id")
+            .annotate(started_estimate_point=Sum(Cast("estimate_point__value", FloatField())))
+            .values("started_estimate_point")[:1]
+        )
+        cancelled_estimate_point = (
+            Issue.issue_objects.filter(
+                estimate_point__estimate__type="points",
+                state__group="cancelled",
+                issue_cycle__cycle_id=OuterRef("pk"),
+                issue_cycle__deleted_at__isnull=True,
+            )
+            .values("issue_cycle__cycle_id")
+            .annotate(cancelled_estimate_point=Sum(Cast("estimate_point__value", FloatField())))
+            .values("cancelled_estimate_point")[:1]
+        )
+        completed_estimate_point = (
+            Issue.issue_objects.filter(
+                estimate_point__estimate__type="points",
+                state__group="completed",
+                issue_cycle__cycle_id=OuterRef("pk"),
+                issue_cycle__deleted_at__isnull=True,
+            )
+            .values("issue_cycle__cycle_id")
+            .annotate(completed_estimate_points=Sum(Cast("estimate_point__value", FloatField())))
+            .values("completed_estimate_points")[:1]
+        )
+        total_estimate_point = (
+            Issue.issue_objects.filter(
+                estimate_point__estimate__type="points",
+                issue_cycle__cycle_id=OuterRef("pk"),
+                issue_cycle__deleted_at__isnull=True,
+            )
+            .values("issue_cycle__cycle_id")
+            .annotate(total_estimate_points=Sum(Cast("estimate_point__value", FloatField())))
+            .values("total_estimate_points")[:1]
+        )
+        return (
+            Cycle.objects.filter(workspace__slug=self.kwargs.get("slug"))
+            .filter(project_id=self.kwargs.get("project_id"))
+            .filter(archived_at__isnull=False)
+            .filter(
+                project__project_projectmember__member=self.request.user,
+                project__project_projectmember__is_active=True,
+            )
+            .filter(project__archived_at__isnull=True)
+            .select_related("project", "workspace", "owned_by")
+            .prefetch_related(
+                Prefetch(
+                    "issue_cycle__issue__assignees",
+                    queryset=User.objects.only("avatar_asset", "first_name", "id").distinct(),
+                )
+            )
+            .prefetch_related(
+                Prefetch(
+                    "issue_cycle__issue__labels",
+                    queryset=Label.objects.only("name", "color", "id").distinct(),
+                )
+            )
+            .annotate(is_favorite=Exists(favorite_subquery))
+            .annotate(
+                total_issues=Count(
+                    "issue_cycle__issue__id",
+                    distinct=True,
+                    filter=Q(
+                        issue_cycle__issue__archived_at__isnull=True,
+                        issue_cycle__issue__is_draft=False,
+                        issue_cycle__issue__deleted_at__isnull=True,
+                    ),
+                )
+            )
+            .annotate(
+                completed_issues=Count(
+                    "issue_cycle__issue__id",
+                    distinct=True,
+                    filter=Q(
+                        issue_cycle__issue__state__group="completed",
+                        issue_cycle__issue__archived_at__isnull=True,
+                        issue_cycle__issue__is_draft=False,
+                        issue_cycle__issue__deleted_at__isnull=True,
+                    ),
+                )
+            )
+            .annotate(
+                cancelled_issues=Count(
+                    "issue_cycle__issue__id",
+                    distinct=True,
+                    filter=Q(
+                        issue_cycle__issue__state__group="cancelled",
+                        issue_cycle__issue__archived_at__isnull=True,
+                        issue_cycle__issue__is_draft=False,
+                        issue_cycle__issue__deleted_at__isnull=True,
+                    ),
+                )
+            )
+            .annotate(
+                started_issues=Count(
+                    "issue_cycle__issue__id",
+                    distinct=True,
+                    filter=Q(
+                        issue_cycle__issue__state__group="started",
+                        issue_cycle__issue__archived_at__isnull=True,
+                        issue_cycle__issue__is_draft=False,
+                        issue_cycle__issue__deleted_at__isnull=True,
+                    ),
+                )
+            )
+            .annotate(
+                unstarted_issues=Count(
+                    "issue_cycle__issue__id",
+                    distinct=True,
+                    filter=Q(
+                        issue_cycle__issue__state__group="unstarted",
+                        issue_cycle__issue__archived_at__isnull=True,
+                        issue_cycle__issue__is_draft=False,
+                        issue_cycle__issue__deleted_at__isnull=True,
+                    ),
+                )
+            )
+            .annotate(
+                backlog_issues=Count(
+                    "issue_cycle__issue__id",
+                    distinct=True,
+                    filter=Q(
+                        issue_cycle__issue__state__group="backlog",
+                        issue_cycle__issue__archived_at__isnull=True,
+                        issue_cycle__issue__is_draft=False,
+                        issue_cycle__issue__deleted_at__isnull=True,
+                    ),
+                )
+            )
+            .annotate(
+                status=Case(
+                    When(
+                        Q(start_date__lte=timezone.now()) & Q(end_date__gte=timezone.now()),
+                        then=Value("CURRENT"),
+                    ),
+                    When(start_date__gt=timezone.now(), then=Value("UPCOMING")),
+                    When(end_date__lt=timezone.now(), then=Value("COMPLETED")),
+                    When(
+                        Q(start_date__isnull=True) & Q(end_date__isnull=True),
+                        then=Value("DRAFT"),
+                    ),
+                    default=Value("DRAFT"),
+                    output_field=CharField(),
+                )
+            )
+            .annotate(
+                assignee_ids=Coalesce(
+                    ArrayAgg(
+                        "issue_cycle__issue__assignees__id",
+                        distinct=True,
+                        filter=~Q(issue_cycle__issue__assignees__id__isnull=True),
+                    ),
+                    Value([], output_field=ArrayField(UUIDField())),
+                )
+            )
+            .annotate(
+                backlog_estimate_points=Coalesce(
+                    Subquery(backlog_estimate_point),
+                    Value(0, output_field=FloatField()),
+                )
+            )
+            .annotate(
+                unstarted_estimate_points=Coalesce(
+                    Subquery(unstarted_estimate_point),
+                    Value(0, output_field=FloatField()),
+                )
+            )
+            .annotate(
+                started_estimate_points=Coalesce(
+                    Subquery(started_estimate_point),
+                    Value(0, output_field=FloatField()),
+                )
+            )
+            .annotate(
+                cancelled_estimate_points=Coalesce(
+                    Subquery(cancelled_estimate_point),
+                    Value(0, output_field=FloatField()),
+                )
+            )
+            .annotate(
+                completed_estimate_points=Coalesce(
+                    Subquery(completed_estimate_point),
+                    Value(0, output_field=FloatField()),
+                )
+            )
+            .annotate(
+                total_estimate_points=Coalesce(Subquery(total_estimate_point), Value(0, output_field=FloatField()))
+            )
+            .order_by("-is_favorite", "name")
+            .distinct()
+        )
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
+    def get(self, request, slug, project_id, pk=None):
+        if pk is None:
+            queryset = (
+                self.get_queryset().values(
+                    # necessary fields
+                    "id",
+                    "workspace_id",
+                    "project_id",
+                    # model fields
+                    "name",
+                    "description",
+                    "start_date",
+                    "end_date",
+                    "owned_by_id",
+                    "view_props",
+                    "sort_order",
+                    "external_source",
+                    "external_id",
+                    "progress_snapshot",
+                    # meta fields
+                    "total_issues",
+                    "is_favorite",
+                    "cancelled_issues",
+                    "completed_issues",
+                    "started_issues",
+                    "unstarted_issues",
+                    "backlog_issues",
+                    "assignee_ids",
+                    "status",
+                    "archived_at",
+                )
+            ).order_by("-is_favorite", "-created_at")
+            return Response(queryset, status=status.HTTP_200_OK)
+        else:
+            queryset = self.get_queryset().filter(archived_at__isnull=False).filter(pk=pk)
+            data = (
+                self.get_queryset()
+                .filter(pk=pk)
+                .annotate(
+                    sub_issues=Issue.issue_objects.filter(
+                        project_id=self.kwargs.get("project_id"),
+                        parent__isnull=False,
+                        issue_cycle__cycle_id=pk,
+                        issue_cycle__deleted_at__isnull=True,
+                    )
+                    .order_by()
+                    .annotate(count=Func(F("id"), function="Count"))
+                    .values("count")
+                )
+                .values(
+                    # necessary fields
+                    "id",
+                    "workspace_id",
+                    "project_id",
+                    # model fields
+                    "name",
+                    "description",
+                    "start_date",
+                    "end_date",
+                    "owned_by_id",
+                    "view_props",
+                    "sort_order",
+                    "external_source",
+                    "external_id",
+                    "progress_snapshot",
+                    "sub_issues",
+                    "logo_props",
+                    # meta fields
+                    "completed_estimate_points",
+                    "total_estimate_points",
+                    "is_favorite",
+                    "total_issues",
+                    "cancelled_issues",
+                    "completed_issues",
+                    "started_issues",
+                    "unstarted_issues",
+                    "backlog_issues",
+                    "assignee_ids",
+                    "status",
+                    "created_by",
+                    "archived_at",
+                )
+                .first()
+            )
+            queryset = queryset.first()
+
+            estimate_type = Project.objects.filter(
+                workspace__slug=slug,
+                pk=project_id,
+                estimate__isnull=False,
+                estimate__type="points",
+            ).exists()
+
+            data["estimate_distribution"] = {}
+            if estimate_type:
+                assignee_distribution = (
+                    Issue.issue_objects.filter(
+                        issue_cycle__cycle_id=pk,
+                        issue_cycle__deleted_at__isnull=True,
+                        workspace__slug=slug,
+                        project_id=project_id,
+                    )
+                    .annotate(display_name=F("assignees__display_name"))
+                    .annotate(assignee_id=F("assignees__id"))
+                    .annotate(
+                        avatar_url=Case(
+                            # If `avatar_asset` exists, use it to generate the asset URL
+                            When(
+                                assignees__avatar_asset__isnull=False,
+                                then=Concat(
+                                    Value("/api/assets/v2/static/"),
+                                    "assignees__avatar_asset",  # Assuming avatar_asset has an id or relevant field
+                                    Value("/"),
+                                ),
+                            ),
+                            # If `avatar_asset` is None, fall back to using `avatar` field directly
+                            When(
+                                assignees__avatar_asset__isnull=True,
+                                then="assignees__avatar",
+                            ),
+                            default=Value(None),
+                            output_field=models.CharField(),
+                        )
+                    )
+                    .values("display_name", "assignee_id", "avatar_url")
+                    .annotate(total_estimates=Sum(Cast("estimate_point__value", FloatField())))
+                    .annotate(
+                        completed_estimates=Sum(
+                            Cast("estimate_point__value", FloatField()),
+                            filter=Q(
+                                completed_at__isnull=False,
+                                archived_at__isnull=True,
+                                is_draft=False,
+                            ),
+                        )
+                    )
+                    .annotate(
+                        pending_estimates=Sum(
+                            Cast("estimate_point__value", FloatField()),
+                            filter=Q(
+                                completed_at__isnull=True,
+                                archived_at__isnull=True,
+                                is_draft=False,
+                            ),
+                        )
+                    )
+                    .order_by("display_name")
+                )
+
+                label_distribution = (
+                    Issue.issue_objects.filter(
+                        issue_cycle__cycle_id=pk,
+                        issue_cycle__deleted_at__isnull=True,
+                        workspace__slug=slug,
+                        project_id=project_id,
+                    )
+                    .annotate(label_name=F("labels__name"))
+                    .annotate(color=F("labels__color"))
+                    .annotate(label_id=F("labels__id"))
+                    .values("label_name", "color", "label_id")
+                    .annotate(total_estimates=Sum(Cast("estimate_point__value", FloatField())))
+                    .annotate(
+                        completed_estimates=Sum(
+                            Cast("estimate_point__value", FloatField()),
+                            filter=Q(
+                                completed_at__isnull=False,
+                                archived_at__isnull=True,
+                                is_draft=False,
+                            ),
+                        )
+                    )
+                    .annotate(
+                        pending_estimates=Sum(
+                            Cast("estimate_point__value", FloatField()),
+                            filter=Q(
+                                completed_at__isnull=True,
+                                archived_at__isnull=True,
+                                is_draft=False,
+                            ),
+                        )
+                    )
+                    .order_by("label_name")
+                )
+                data["estimate_distribution"] = {
+                    "assignees": assignee_distribution,
+                    "labels": label_distribution,
+                    "completion_chart": {},
+                }
+
+                if data["start_date"] and data["end_date"]:
+                    data["estimate_distribution"]["completion_chart"] = burndown_plot(
+                        queryset=queryset,
+                        slug=slug,
+                        project_id=project_id,
+                        plot_type="points",
+                        cycle_id=pk,
+                    )
+
+            # Assignee Distribution
+            assignee_distribution = (
+                Issue.issue_objects.filter(
+                    issue_cycle__cycle_id=pk,
+                    issue_cycle__deleted_at__isnull=True,
+                    workspace__slug=slug,
+                    project_id=project_id,
+                )
+                .annotate(first_name=F("assignees__first_name"))
+                .annotate(last_name=F("assignees__last_name"))
+                .annotate(assignee_id=F("assignees__id"))
+                .annotate(
+                    avatar_url=Case(
+                        # If `avatar_asset` exists, use it to generate the asset URL
+                        When(
+                            assignees__avatar_asset__isnull=False,
+                            then=Concat(
+                                Value("/api/assets/v2/static/"),
+                                "assignees__avatar_asset",  # Assuming avatar_asset has an id or relevant field
+                                Value("/"),
+                            ),
+                        ),
+                        # If `avatar_asset` is None, fall back to using `avatar` field directly
+                        When(
+                            assignees__avatar_asset__isnull=True,
+                            then="assignees__avatar",
+                        ),
+                        default=Value(None),
+                        output_field=models.CharField(),
+                    )
+                )
+                .annotate(display_name=F("assignees__display_name"))
+                .values(
+                    "first_name",
+                    "last_name",
+                    "assignee_id",
+                    "avatar_url",
+                    "display_name",
+                )
+                .annotate(total_issues=Count("id", filter=Q(archived_at__isnull=True, is_draft=False)))
+                .annotate(
+                    completed_issues=Count(
+                        "id",
+                        filter=Q(
+                            completed_at__isnull=False,
+                            archived_at__isnull=True,
+                            is_draft=False,
+                        ),
+                    )
+                )
+                .annotate(
+                    pending_issues=Count(
+                        "id",
+                        filter=Q(
+                            completed_at__isnull=True,
+                            archived_at__isnull=True,
+                            is_draft=False,
+                        ),
+                    )
+                )
+                .order_by("first_name", "last_name")
+            )
+
+            # Label Distribution
+            label_distribution = (
+                Issue.issue_objects.filter(
+                    issue_cycle__cycle_id=pk,
+                    issue_cycle__deleted_at__isnull=True,
+                    workspace__slug=slug,
+                    project_id=project_id,
+                )
+                .annotate(label_name=F("labels__name"))
+                .annotate(color=F("labels__color"))
+                .annotate(label_id=F("labels__id"))
+                .values("label_name", "color", "label_id")
+                .annotate(total_issues=Count("id", filter=Q(archived_at__isnull=True, is_draft=False)))
+                .annotate(
+                    completed_issues=Count(
+                        "id",
+                        filter=Q(
+                            completed_at__isnull=False,
+                            archived_at__isnull=True,
+                            is_draft=False,
+                        ),
+                    )
+                )
+                .annotate(
+                    pending_issues=Count(
+                        "id",
+                        filter=Q(
+                            completed_at__isnull=True,
+                            archived_at__isnull=True,
+                            is_draft=False,
+                        ),
+                    )
+                )
+                .order_by("label_name")
+            )
+
+            data["distribution"] = {
+                "assignees": assignee_distribution,
+                "labels": label_distribution,
+                "completion_chart": {},
+            }
+
+            if queryset.start_date and queryset.end_date:
+                data["distribution"]["completion_chart"] = burndown_plot(
+                    queryset=queryset,
+                    slug=slug,
+                    project_id=project_id,
+                    plot_type="issues",
+                    cycle_id=pk,
+                )
+
+            return Response(data, status=status.HTTP_200_OK)
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
+    def post(self, request, slug, project_id, cycle_id):
+        cycle = Cycle.objects.get(pk=cycle_id, project_id=project_id, workspace__slug=slug)
+
+        if cycle.end_date >= timezone.now():
+            return Response(
+                {"error": "Only completed cycles can be archived"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        cycle.archived_at = timezone.now()
+        cycle.save()
+        UserFavorite.objects.filter(
+            entity_type="cycle",
+            entity_identifier=cycle_id,
+            project_id=project_id,
+            workspace__slug=slug,
+        ).delete()
+        return Response({"archived_at": str(cycle.archived_at)}, status=status.HTTP_200_OK)
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
+    def delete(self, request, slug, project_id, cycle_id):
+        cycle = Cycle.objects.get(pk=cycle_id, project_id=project_id, workspace__slug=slug)
+        cycle.archived_at = None
+        cycle.save()
+        return Response(status=status.HTTP_204_NO_CONTENT)

plane-src/apps/api/plane/app/views/cycle/issue.py

@@ -0,0 +1,324 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+# Python imports
+import copy
+import json
+
+# Django imports
+from django.core import serializers
+from django.db.models import F, Func, OuterRef, Q, Subquery
+from django.utils import timezone
+from django.utils.decorators import method_decorator
+from django.views.decorators.gzip import gzip_page
+
+# Third party imports
+from rest_framework import status
+from rest_framework.response import Response
+
+
+# Module imports
+from .. import BaseViewSet
+from plane.app.serializers import CycleIssueSerializer
+from plane.bgtasks.issue_activities_task import issue_activity
+from plane.db.models import Cycle, CycleIssue, Issue, FileAsset, IssueLink
+from plane.utils.grouper import (
+    issue_group_values,
+    issue_on_results,
+    issue_queryset_grouper,
+)
+from plane.utils.issue_filters import issue_filters
+from plane.utils.order_queryset import order_issue_queryset
+from plane.utils.paginator import GroupedOffsetPaginator, SubGroupedOffsetPaginator
+from plane.app.permissions import allow_permission, ROLE
+from plane.utils.host import base_host
+from plane.utils.filters import ComplexFilterBackend
+from plane.utils.filters import IssueFilterSet
+
+
+class CycleIssueViewSet(BaseViewSet):
+    serializer_class = CycleIssueSerializer
+    model = CycleIssue
+    filter_backends = (ComplexFilterBackend,)
+    filterset_class = IssueFilterSet
+
+    webhook_event = "cycle_issue"
+    bulk = True
+
+    filterset_fields = ["issue__labels__id", "issue__assignees__id"]
+
+    def get_queryset(self):
+        return self.filter_queryset(
+            super()
+            .get_queryset()
+            .annotate(
+                sub_issues_count=Issue.issue_objects.filter(parent=OuterRef("issue_id"))
+                .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(
+                project__project_projectmember__member=self.request.user,
+                project__project_projectmember__is_active=True,
+            )
+            .filter(project__archived_at__isnull=True)
+            .filter(cycle_id=self.kwargs.get("cycle_id"))
+            .select_related("project")
+            .select_related("workspace")
+            .select_related("cycle")
+            .select_related("issue", "issue__state", "issue__project")
+            .prefetch_related("issue__assignees", "issue__labels")
+            .distinct()
+        )
+
+    def apply_annotations(self, issues):
+        return (
+            issues.annotate(
+                cycle_id=Subquery(
+                    CycleIssue.objects.filter(issue=OuterRef("id"), deleted_at__isnull=True).values("cycle_id")[:1]
+                )
+            )
+            .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")
+            )
+            .annotate(
+                sub_issues_count=Issue.issue_objects.filter(parent=OuterRef("id"))
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
+            .prefetch_related("assignees", "labels", "issue_module__module", "issue_cycle__cycle")
+        )
+
+    @method_decorator(gzip_page)
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
+    def list(self, request, slug, project_id, cycle_id):
+        filters = issue_filters(request.query_params, "GET")
+        issue_queryset = (
+            Issue.issue_objects.filter(issue_cycle__cycle_id=cycle_id, issue_cycle__deleted_at__isnull=True)
+            .filter(project_id=project_id)
+            .filter(workspace__slug=slug)
+        )
+
+        # Apply filtering from filterset
+        issue_queryset = self.filter_queryset(issue_queryset)
+
+        # Apply legacy filters
+        issue_queryset = issue_queryset.filter(**filters)
+
+        # Total count queryset
+        total_issue_queryset = copy.deepcopy(issue_queryset)
+
+        # Applying annotations to the issue queryset
+        issue_queryset = self.apply_annotations(issue_queryset)
+
+        order_by_param = request.GET.get("order_by", "-created_at")
+        # Issue queryset
+        issue_queryset, order_by_param = order_issue_queryset(
+            issue_queryset=issue_queryset, order_by_param=order_by_param
+        )
+
+        # Group by
+        group_by = request.GET.get("group_by", False)
+        sub_group_by = request.GET.get("sub_group_by", False)
+
+        # issue queryset
+        issue_queryset = issue_queryset_grouper(queryset=issue_queryset, group_by=group_by, sub_group_by=sub_group_by)
+
+        if group_by:
+            # Check group and sub group value paginate
+            if sub_group_by:
+                if group_by == sub_group_by:
+                    return Response(
+                        {"error": "Group by and sub group by cannot have same parameters"},
+                        status=status.HTTP_400_BAD_REQUEST,
+                    )
+                else:
+                    # group and sub group pagination
+                    return self.paginate(
+                        request=request,
+                        order_by=order_by_param,
+                        queryset=issue_queryset,
+                        total_count_queryset=total_issue_queryset,
+                        on_results=lambda issues: issue_on_results(
+                            group_by=group_by, issues=issues, sub_group_by=sub_group_by
+                        ),
+                        paginator_cls=SubGroupedOffsetPaginator,
+                        group_by_fields=issue_group_values(
+                            field=group_by,
+                            slug=slug,
+                            project_id=project_id,
+                            filters=filters,
+                        ),
+                        sub_group_by_fields=issue_group_values(
+                            field=sub_group_by,
+                            slug=slug,
+                            project_id=project_id,
+                            filters=filters,
+                        ),
+                        group_by_field_name=group_by,
+                        sub_group_by_field_name=sub_group_by,
+                        count_filter=Q(
+                            Q(issue_intake__status=1)
+                            | Q(issue_intake__status=-1)
+                            | Q(issue_intake__status=2)
+                            | Q(issue_intake__isnull=True),
+                            archived_at__isnull=True,
+                            is_draft=False,
+                        ),
+                    )
+            # Group Paginate
+            else:
+                # Group paginate
+                return self.paginate(
+                    request=request,
+                    order_by=order_by_param,
+                    queryset=issue_queryset,
+                    total_count_queryset=total_issue_queryset,
+                    on_results=lambda issues: issue_on_results(
+                        group_by=group_by, issues=issues, sub_group_by=sub_group_by
+                    ),
+                    paginator_cls=GroupedOffsetPaginator,
+                    group_by_fields=issue_group_values(
+                        field=group_by,
+                        slug=slug,
+                        project_id=project_id,
+                        filters=filters,
+                    ),
+                    group_by_field_name=group_by,
+                    count_filter=Q(
+                        Q(issue_intake__status=1)
+                        | Q(issue_intake__status=-1)
+                        | Q(issue_intake__status=2)
+                        | Q(issue_intake__isnull=True),
+                        archived_at__isnull=True,
+                        is_draft=False,
+                    ),
+                )
+        else:
+            # List Paginate
+            return self.paginate(
+                order_by=order_by_param,
+                request=request,
+                queryset=issue_queryset,
+                total_count_queryset=total_issue_queryset,
+                on_results=lambda issues: issue_on_results(group_by=group_by, issues=issues, sub_group_by=sub_group_by),
+            )
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
+    def create(self, request, slug, project_id, cycle_id):
+        issues = request.data.get("issues", [])
+
+        if not issues:
+            return Response({"error": "Issues are required"}, status=status.HTTP_400_BAD_REQUEST)
+
+        cycle = Cycle.objects.get(workspace__slug=slug, project_id=project_id, pk=cycle_id)
+
+        if cycle.end_date is not None and cycle.end_date < timezone.now():
+            return Response(
+                {"error": "The Cycle has already been completed so no new issues can be added"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # Get all CycleIssues already created
+        cycle_issues = list(CycleIssue.objects.filter(~Q(cycle_id=cycle_id), issue_id__in=issues))
+        existing_issues = [str(cycle_issue.issue_id) for cycle_issue in cycle_issues]
+        new_issues = list(set(issues) - set(existing_issues))
+
+        # New issues to create
+        created_records = CycleIssue.objects.bulk_create(
+            [
+                CycleIssue(
+                    project_id=project_id,
+                    workspace_id=cycle.workspace_id,
+                    created_by_id=request.user.id,
+                    updated_by_id=request.user.id,
+                    cycle_id=cycle_id,
+                    issue_id=issue,
+                )
+                for issue in new_issues
+            ],
+            batch_size=10,
+        )
+
+        # Updated Issues
+        updated_records = []
+        update_cycle_issue_activity = []
+        # Iterate over each cycle_issue in cycle_issues
+        for cycle_issue in cycle_issues:
+            old_cycle_id = cycle_issue.cycle_id
+            # Update the cycle_issue's cycle_id
+            cycle_issue.cycle_id = cycle_id
+            # Add the modified cycle_issue to the records_to_update list
+            updated_records.append(cycle_issue)
+            # Record the update activity
+            update_cycle_issue_activity.append(
+                {
+                    "old_cycle_id": str(old_cycle_id),
+                    "new_cycle_id": str(cycle_id),
+                    "issue_id": str(cycle_issue.issue_id),
+                }
+            )
+
+        # Update the cycle issues
+        CycleIssue.objects.bulk_update(updated_records, ["cycle_id"], batch_size=100)
+        # Capture Issue Activity
+        issue_activity.delay(
+            type="cycle.activity.created",
+            requested_data=json.dumps({"cycles_list": issues}),
+            actor_id=str(self.request.user.id),
+            issue_id=None,
+            project_id=str(self.kwargs.get("project_id", None)),
+            current_instance=json.dumps(
+                {
+                    "updated_cycle_issues": update_cycle_issue_activity,
+                    "created_cycle_issues": serializers.serialize("json", created_records),
+                }
+            ),
+            epoch=int(timezone.now().timestamp()),
+            notification=True,
+            origin=base_host(request=request, is_app=True),
+        )
+        return Response({"message": "success"}, status=status.HTTP_201_CREATED)
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
+    def destroy(self, request, slug, project_id, cycle_id, issue_id):
+        cycle_issue = CycleIssue.objects.filter(
+            issue_id=issue_id,
+            workspace__slug=slug,
+            project_id=project_id,
+            cycle_id=cycle_id,
+        )
+        issue_activity.delay(
+            type="cycle.activity.deleted",
+            requested_data=json.dumps(
+                {
+                    "cycle_id": str(self.kwargs.get("cycle_id")),
+                    "issues": [str(issue_id)],
+                }
+            ),
+            actor_id=str(self.request.user.id),
+            issue_id=str(issue_id),
+            project_id=str(self.kwargs.get("project_id", None)),
+            current_instance=None,
+            epoch=int(timezone.now().timestamp()),
+            notification=True,
+            origin=base_host(request=request, is_app=True),
+        )
+        cycle_issue.delete()
+        return Response(status=status.HTTP_204_NO_CONTENT)

plane-src/apps/api/plane/app/views/error_404.py

@@ -0,0 +1,10 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+# views.py
+from django.http import JsonResponse
+
+
+def custom_404_view(request, exception=None):
+    return JsonResponse({"error": "Page not found."}, status=404)

plane-src/apps/api/plane/app/views/estimate/base.py

@@ -0,0 +1,247 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+import random
+import string
+import json
+
+# Django imports
+from django.utils import timezone
+
+# Third party imports
+from rest_framework.response import Response
+from rest_framework import status
+
+# Module imports
+from ..base import BaseViewSet, BaseAPIView
+from plane.app.permissions import ProjectEntityPermission, allow_permission, ROLE
+from plane.db.models import Project, Estimate, EstimatePoint, Issue
+from plane.app.serializers import (
+    EstimateSerializer,
+    EstimatePointSerializer,
+    EstimateReadSerializer,
+)
+from plane.utils.cache import invalidate_cache
+from plane.bgtasks.issue_activities_task import issue_activity
+
+
+def generate_random_name(length=10):
+    letters = string.ascii_lowercase
+    return "".join(random.choice(letters) for i in range(length))
+
+
+class ProjectEstimatePointEndpoint(BaseAPIView):
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
+    def get(self, request, slug, project_id):
+        project = Project.objects.get(workspace__slug=slug, pk=project_id)
+        if project.estimate_id is not None:
+            estimate_points = EstimatePoint.objects.filter(
+                estimate_id=project.estimate_id,
+                project_id=project_id,
+                workspace__slug=slug,
+            )
+            serializer = EstimatePointSerializer(estimate_points, many=True)
+            return Response(serializer.data, status=status.HTTP_200_OK)
+        return Response([], status=status.HTTP_200_OK)
+
+
+class BulkEstimatePointEndpoint(BaseViewSet):
+    permission_classes = [ProjectEntityPermission]
+    model = Estimate
+    serializer_class = EstimateSerializer
+
+    def list(self, request, slug, project_id):
+        estimates = (
+            Estimate.objects.filter(workspace__slug=slug, project_id=project_id)
+            .prefetch_related("points")
+            .select_related("workspace", "project")
+        )
+        serializer = EstimateReadSerializer(estimates, many=True)
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+    @invalidate_cache(path="/api/workspaces/:slug/estimates/", url_params=True, user=False)
+    def create(self, request, slug, project_id):
+        estimate = request.data.get("estimate")
+        estimate_name = estimate.get("name", generate_random_name())
+        estimate_type = estimate.get("type", "categories")
+        last_used = estimate.get("last_used", False)
+        estimate = Estimate.objects.create(
+            name=estimate_name,
+            project_id=project_id,
+            last_used=last_used,
+            type=estimate_type,
+        )
+
+        estimate_points = request.data.get("estimate_points", [])
+
+        serializer = EstimatePointSerializer(data=request.data.get("estimate_points"), many=True)
+        if not serializer.is_valid():
+            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+        estimate_points = EstimatePoint.objects.bulk_create(
+            [
+                EstimatePoint(
+                    estimate=estimate,
+                    key=estimate_point.get("key", 0),
+                    value=estimate_point.get("value", ""),
+                    description=estimate_point.get("description", ""),
+                    project_id=project_id,
+                    workspace_id=estimate.workspace_id,
+                    created_by=request.user,
+                    updated_by=request.user,
+                )
+                for estimate_point in estimate_points
+            ],
+            batch_size=10,
+            ignore_conflicts=True,
+        )
+
+        serializer = EstimateReadSerializer(estimate)
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+    def retrieve(self, request, slug, project_id, estimate_id):
+        estimate = Estimate.objects.get(pk=estimate_id, workspace__slug=slug, project_id=project_id)
+        serializer = EstimateReadSerializer(estimate)
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+    @invalidate_cache(path="/api/workspaces/:slug/estimates/", url_params=True, user=False)
+    def partial_update(self, request, slug, project_id, estimate_id):
+        if not len(request.data.get("estimate_points", [])):
+            return Response(
+                {"error": "Estimate points are required"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        estimate = Estimate.objects.get(pk=estimate_id)
+
+        if request.data.get("estimate"):
+            estimate.name = request.data.get("estimate").get("name", estimate.name)
+            estimate.type = request.data.get("estimate").get("type", estimate.type)
+            estimate.save()
+
+        estimate_points_data = request.data.get("estimate_points", [])
+
+        estimate_points = EstimatePoint.objects.filter(
+            pk__in=[estimate_point.get("id") for estimate_point in estimate_points_data],
+            workspace__slug=slug,
+            project_id=project_id,
+            estimate_id=estimate_id,
+        )
+
+        updated_estimate_points = []
+        for estimate_point in estimate_points:
+            # Find the data for that estimate point
+            estimate_point_data = [point for point in estimate_points_data if point.get("id") == str(estimate_point.id)]
+            if len(estimate_point_data):
+                estimate_point.value = estimate_point_data[0].get("value", estimate_point.value)
+                estimate_point.key = estimate_point_data[0].get("key", estimate_point.key)
+                updated_estimate_points.append(estimate_point)
+
+        EstimatePoint.objects.bulk_update(updated_estimate_points, ["key", "value"], batch_size=10)
+
+        estimate_serializer = EstimateReadSerializer(estimate)
+        return Response(estimate_serializer.data, status=status.HTTP_200_OK)
+
+    @invalidate_cache(path="/api/workspaces/:slug/estimates/", url_params=True, user=False)
+    def destroy(self, request, slug, project_id, estimate_id):
+        estimate = Estimate.objects.get(pk=estimate_id, workspace__slug=slug, project_id=project_id)
+        estimate.delete()
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+class EstimatePointEndpoint(BaseViewSet):
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
+    def create(self, request, slug, project_id, estimate_id):
+        #  TODO: add a key validation if the same key already exists
+        if not request.data.get("key") or not request.data.get("value"):
+            return Response(
+                {"error": "Key and value are required"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+        key = request.data.get("key", 0)
+        value = request.data.get("value", "")
+        estimate_point = EstimatePoint.objects.create(
+            estimate_id=estimate_id, project_id=project_id, key=key, value=value
+        )
+        serializer = EstimatePointSerializer(estimate_point).data
+        return Response(serializer, status=status.HTTP_200_OK)
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
+    def partial_update(self, request, slug, project_id, estimate_id, estimate_point_id):
+        #  TODO: add a key validation if the same key already exists
+        estimate_point = EstimatePoint.objects.get(
+            pk=estimate_point_id,
+            estimate_id=estimate_id,
+            project_id=project_id,
+            workspace__slug=slug,
+        )
+        serializer = EstimatePointSerializer(estimate_point, data=request.data, partial=True)
+        if not serializer.is_valid():
+            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+        serializer.save()
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
+    def destroy(self, request, slug, project_id, estimate_id, estimate_point_id):
+        new_estimate_id = request.data.get("new_estimate_id", None)
+        estimate_points = EstimatePoint.objects.filter(
+            estimate_id=estimate_id, project_id=project_id, workspace__slug=slug
+        )
+        # update all the issues with the new estimate
+        if new_estimate_id:
+            issues = Issue.objects.filter(
+                project_id=project_id,
+                workspace__slug=slug,
+                estimate_point_id=estimate_point_id,
+            )
+            for issue in issues:
+                issue_activity.delay(
+                    type="issue.activity.updated",
+                    requested_data=json.dumps({"estimate_point": (str(new_estimate_id) if new_estimate_id else None)}),
+                    actor_id=str(request.user.id),
+                    issue_id=issue.id,
+                    project_id=str(project_id),
+                    current_instance=json.dumps(
+                        {"estimate_point": (str(issue.estimate_point_id) if issue.estimate_point_id else None)}
+                    ),
+                    epoch=int(timezone.now().timestamp()),
+                )
+                issues.update(estimate_point_id=new_estimate_id)
+        else:
+            issues = Issue.objects.filter(
+                project_id=project_id,
+                workspace__slug=slug,
+                estimate_point_id=estimate_point_id,
+            )
+            for issue in issues:
+                issue_activity.delay(
+                    type="issue.activity.updated",
+                    requested_data=json.dumps({"estimate_point": None}),
+                    actor_id=str(request.user.id),
+                    issue_id=issue.id,
+                    project_id=str(project_id),
+                    current_instance=json.dumps(
+                        {"estimate_point": (str(issue.estimate_point_id) if issue.estimate_point_id else None)}
+                    ),
+                    epoch=int(timezone.now().timestamp()),
+                )
+
+        # delete the estimate point
+        old_estimate_point = EstimatePoint.objects.filter(pk=estimate_point_id).first()
+
+        # rearrange the estimate points
+        updated_estimate_points = []
+        for estimate_point in estimate_points:
+            if estimate_point.key > old_estimate_point.key:
+                estimate_point.key -= 1
+                updated_estimate_points.append(estimate_point)
+
+        EstimatePoint.objects.bulk_update(updated_estimate_points, ["key"], batch_size=10)
+
+        old_estimate_point.delete()
+
+        return Response(
+            EstimatePointSerializer(updated_estimate_points, many=True).data,
+            status=status.HTTP_200_OK,
+        )

plane-src/apps/api/plane/app/views/exporter/base.py

@@ -0,0 +1,84 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+# Third Party imports
+from rest_framework import status
+from rest_framework.response import Response
+
+from plane.app.permissions import allow_permission, ROLE
+from plane.app.serializers import ExporterHistorySerializer
+from plane.bgtasks.export_task import issue_export_task
+from plane.db.models import ExporterHistory, Project, Workspace
+
+# Module imports
+from .. import BaseAPIView
+
+
+class ExportIssuesEndpoint(BaseAPIView):
+    model = ExporterHistory
+    serializer_class = ExporterHistorySerializer
+
+    @allow_permission(allowed_roles=[ROLE.ADMIN, ROLE.MEMBER], level="WORKSPACE")
+    def post(self, request, slug):
+        # Get the workspace
+        workspace = Workspace.objects.get(slug=slug)
+
+        provider = request.data.get("provider", False)
+        multiple = request.data.get("multiple", False)
+        project_ids = request.data.get("project", [])
+
+        if provider in ["csv", "xlsx", "json"]:
+            if not project_ids:
+                project_ids = Project.objects.filter(
+                    workspace__slug=slug,
+                    project_projectmember__member=request.user,
+                    project_projectmember__is_active=True,
+                    archived_at__isnull=True,
+                ).values_list("id", flat=True)
+                project_ids = [str(project_id) for project_id in project_ids]
+
+            exporter = ExporterHistory.objects.create(
+                workspace=workspace,
+                project=project_ids,
+                initiated_by=request.user,
+                provider=provider,
+                type="issue_exports",
+            )
+
+            issue_export_task.delay(
+                provider=exporter.provider,
+                workspace_id=workspace.id,
+                project_ids=project_ids,
+                token_id=exporter.token,
+                multiple=multiple,
+                slug=slug,
+            )
+            return Response(
+                {"message": "Once the export is ready you will be able to download it"},
+                status=status.HTTP_200_OK,
+            )
+        else:
+            return Response(
+                {"error": f"Provider '{provider}' not found."},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+    @allow_permission(allowed_roles=[ROLE.ADMIN, ROLE.MEMBER], level="WORKSPACE")
+    def get(self, request, slug):
+        exporter_history = ExporterHistory.objects.filter(workspace__slug=slug, type="issue_exports").select_related(
+            "workspace", "initiated_by"
+        )
+
+        if request.GET.get("per_page", False) and request.GET.get("cursor", False):
+            return self.paginate(
+                order_by=request.GET.get("order_by", "-created_at"),
+                request=request,
+                queryset=exporter_history,
+                on_results=lambda exporter_history: ExporterHistorySerializer(exporter_history, many=True).data,
+            )
+        else:
+            return Response(
+                {"error": "per_page and cursor are required"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )

plane-src/apps/api/plane/app/views/external/base.py

@@ -0,0 +1,243 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+# Python import
+import os
+from typing import List, Dict, Tuple
+
+# Third party import
+from openai import OpenAI
+import requests
+
+from rest_framework import status
+from rest_framework.response import Response
+
+# Module import
+from plane.app.permissions import ROLE, allow_permission
+from plane.app.serializers import ProjectLiteSerializer, WorkspaceLiteSerializer
+from plane.db.models import Project, Workspace
+from plane.license.utils.instance_value import get_configuration_value
+from plane.utils.exception_logger import log_exception
+
+from ..base import BaseAPIView
+
+
+class LLMProvider:
+    """Base class for LLM provider configurations"""
+
+    name: str = ""
+    models: List[str] = []
+    default_model: str = ""
+
+    @classmethod
+    def get_config(cls) -> Dict[str, str | List[str]]:
+        return {
+            "name": cls.name,
+            "models": cls.models,
+            "default_model": cls.default_model,
+        }
+
+
+class OpenAIProvider(LLMProvider):
+    name = "OpenAI"
+    models = ["gpt-3.5-turbo", "gpt-4o-mini", "gpt-4o", "o1-mini", "o1-preview"]
+    default_model = "gpt-4o-mini"
+
+
+class AnthropicProvider(LLMProvider):
+    name = "Anthropic"
+    models = [
+        "claude-3-5-sonnet-20240620",
+        "claude-3-haiku-20240307",
+        "claude-3-opus-20240229",
+        "claude-3-sonnet-20240229",
+        "claude-2.1",
+        "claude-2",
+        "claude-instant-1.2",
+        "claude-instant-1",
+    ]
+    default_model = "claude-3-sonnet-20240229"
+
+
+class GeminiProvider(LLMProvider):
+    name = "Gemini"
+    models = ["gemini-pro", "gemini-1.5-pro-latest", "gemini-pro-vision"]
+    default_model = "gemini-pro"
+
+
+SUPPORTED_PROVIDERS = {
+    "openai": OpenAIProvider,
+    "anthropic": AnthropicProvider,
+    "gemini": GeminiProvider,
+}
+
+
+def get_llm_config() -> Tuple[str | None, str | None, str | None]:
+    """
+    Helper to get LLM configuration values, returns:
+        - api_key, model, provider
+    """
+    api_key, provider_key, model = get_configuration_value(
+        [
+            {
+                "key": "LLM_API_KEY",
+                "default": os.environ.get("LLM_API_KEY", None),
+            },
+            {
+                "key": "LLM_PROVIDER",
+                "default": os.environ.get("LLM_PROVIDER", "openai"),
+            },
+            {
+                "key": "LLM_MODEL",
+                "default": os.environ.get("LLM_MODEL", None),
+            },
+        ]
+    )
+
+    provider = SUPPORTED_PROVIDERS.get(provider_key.lower())
+    if not provider:
+        log_exception(ValueError(f"Unsupported provider: {provider_key}"))
+        return None, None, None
+
+    if not api_key:
+        log_exception(ValueError(f"Missing API key for provider: {provider.name}"))
+        return None, None, None
+
+    # If no model specified, use provider's default
+    if not model:
+        model = provider.default_model
+
+    # Validate model is supported by provider
+    if model not in provider.models:
+        log_exception(
+            ValueError(
+                f"Model {model} not supported by {provider.name}. Supported models: {', '.join(provider.models)}"
+            )
+        )
+        return None, None, None
+
+    return api_key, model, provider_key
+
+
+def get_llm_response(task, prompt, api_key: str, model: str, provider: str) -> Tuple[str | None, str | None]:
+    """Helper to get LLM completion response"""
+    final_text = task + "\n" + prompt
+    try:
+        # For Gemini, prepend provider name to model
+        if provider.lower() == "gemini":
+            model = f"gemini/{model}"
+
+        client = OpenAI(api_key=api_key)
+        chat_completion = client.chat.completions.create(
+            model=model, messages=[{"role": "user", "content": final_text}]
+        )
+        text = chat_completion.choices[0].message.content
+        return text, None
+    except Exception as e:
+        log_exception(e)
+        error_type = e.__class__.__name__
+        if error_type == "AuthenticationError":
+            return None, f"Invalid API key for {provider}"
+        elif error_type == "RateLimitError":
+            return None, f"Rate limit exceeded for {provider}"
+        else:
+            return None, f"Error occurred while generating response from {provider}"
+
+
+class GPTIntegrationEndpoint(BaseAPIView):
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
+    def post(self, request, slug, project_id):
+        api_key, model, provider = get_llm_config()
+
+        if not api_key or not model or not provider:
+            return Response(
+                {"error": "LLM provider API key and model are required"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        task = request.data.get("task", False)
+        if not task:
+            return Response({"error": "Task is required"}, status=status.HTTP_400_BAD_REQUEST)
+
+        text, error = get_llm_response(task, request.data.get("prompt", False), api_key, model, provider)
+        if not text and error:
+            return Response(
+                {"error": "An internal error has occurred."},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+        workspace = Workspace.objects.get(slug=slug)
+        project = Project.objects.get(pk=project_id)
+
+        return Response(
+            {
+                "response": text,
+                "response_html": text.replace("\n", "<br/>"),
+                "project_detail": ProjectLiteSerializer(project).data,
+                "workspace_detail": WorkspaceLiteSerializer(workspace).data,
+            },
+            status=status.HTTP_200_OK,
+        )
+
+
+class WorkspaceGPTIntegrationEndpoint(BaseAPIView):
+    @allow_permission(allowed_roles=[ROLE.ADMIN, ROLE.MEMBER], level="WORKSPACE")
+    def post(self, request, slug):
+        api_key, model, provider = get_llm_config()
+
+        if not api_key or not model or not provider:
+            return Response(
+                {"error": "LLM provider API key and model are required"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        task = request.data.get("task", False)
+        if not task:
+            return Response({"error": "Task is required"}, status=status.HTTP_400_BAD_REQUEST)
+
+        text, error = get_llm_response(task, request.data.get("prompt", False), api_key, model, provider)
+        if not text and error:
+            return Response(
+                {"error": "An internal error has occurred."},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            )
+
+        return Response(
+            {
+                "response": text,
+                "response_html": text.replace("\n", "<br/>"),
+            },
+            status=status.HTTP_200_OK,
+        )
+
+
+class UnsplashEndpoint(BaseAPIView):
+    def get(self, request):
+        (UNSPLASH_ACCESS_KEY,) = get_configuration_value(
+            [
+                {
+                    "key": "UNSPLASH_ACCESS_KEY",
+                    "default": os.environ.get("UNSPLASH_ACCESS_KEY"),
+                }
+            ]
+        )
+        # Check unsplash access key
+        if not UNSPLASH_ACCESS_KEY:
+            return Response([], status=status.HTTP_200_OK)
+
+        # Query parameters
+        query = request.GET.get("query", False)
+        page = request.GET.get("page", 1)
+        per_page = request.GET.get("per_page", 20)
+
+        url = (
+            f"https://api.unsplash.com/search/photos/?client_id={UNSPLASH_ACCESS_KEY}&query={query}&page=${page}&per_page={per_page}"
+            if query
+            else f"https://api.unsplash.com/photos/?client_id={UNSPLASH_ACCESS_KEY}&page={page}&per_page={per_page}"
+        )
+
+        headers = {"Content-Type": "application/json"}
+
+        resp = requests.get(url=url, headers=headers)
+        return Response(resp.json(), status=resp.status_code)

plane-src/apps/api/plane/app/views/intake/base.py

@@ -0,0 +1,633 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+# Python imports
+import json
+
+# Django import
+from django.utils import timezone
+from django.db.models import Q, Count, OuterRef, Func, F, Prefetch, Subquery
+from django.core.serializers.json import DjangoJSONEncoder
+from django.contrib.postgres.aggregates import ArrayAgg
+from django.contrib.postgres.fields import ArrayField
+from django.db.models import Value, UUIDField
+from django.db.models.functions import Coalesce
+
+# Third party imports
+from rest_framework import status
+from rest_framework.response import Response
+
+# Module imports
+from ..base import BaseViewSet
+from plane.app.permissions import allow_permission, ROLE
+from plane.db.models import (
+    Intake,
+    IntakeIssue,
+    Issue,
+    State,
+    StateGroup,
+    IssueLink,
+    FileAsset,
+    Project,
+    ProjectMember,
+    CycleIssue,
+    IssueDescriptionVersion,
+    WorkspaceMember,
+)
+from plane.app.serializers import (
+    IssueCreateSerializer,
+    IssueDetailSerializer,
+    IntakeSerializer,
+    IntakeIssueSerializer,
+    IntakeIssueDetailSerializer,
+    IssueDescriptionVersionDetailSerializer,
+)
+from plane.utils.issue_filters import issue_filters
+from plane.bgtasks.issue_activities_task import issue_activity
+from plane.bgtasks.issue_description_version_task import issue_description_version_task
+from plane.app.views.base import BaseAPIView
+from plane.utils.timezone_converter import user_timezone_converter
+from plane.utils.global_paginator import paginate
+from plane.utils.host import base_host
+from plane.db.models.intake import SourceType
+
+
+class IntakeViewSet(BaseViewSet):
+    serializer_class = IntakeSerializer
+    model = Intake
+
+    def get_queryset(self):
+        return (
+            super()
+            .get_queryset()
+            .filter(
+                workspace__slug=self.kwargs.get("slug"),
+                project_id=self.kwargs.get("project_id"),
+            )
+            .annotate(pending_issue_count=Count("issue_intake", filter=Q(issue_intake__status=-2)))
+            .select_related("workspace", "project")
+        )
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
+    def list(self, request, slug, project_id):
+        intake = self.get_queryset().first()
+        return Response(IntakeSerializer(intake).data, status=status.HTTP_200_OK)
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
+    def perform_create(self, serializer):
+        serializer.save(project_id=self.kwargs.get("project_id"))
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
+    def destroy(self, request, slug, project_id, pk):
+        intake = Intake.objects.filter(workspace__slug=slug, project_id=project_id, pk=pk).first()
+        # Handle default intake delete
+        if intake.is_default:
+            return Response(
+                {"error": "You cannot delete the default intake"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+        intake.delete()
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+class IntakeIssueViewSet(BaseViewSet):
+    serializer_class = IntakeIssueSerializer
+    model = IntakeIssue
+
+    filterset_fields = ["status"]
+
+    def get_queryset(self):
+        return (
+            Issue.objects.filter(
+                project_id=self.kwargs.get("project_id"),
+                workspace__slug=self.kwargs.get("slug"),
+            )
+            .select_related("workspace", "project", "state", "parent")
+            .prefetch_related("assignees", "labels", "issue_module__module")
+            .prefetch_related(
+                Prefetch(
+                    "issue_intake",
+                    queryset=IntakeIssue.objects.only("status", "duplicate_to", "snoozed_till", "source"),
+                )
+            )
+            .annotate(
+                cycle_id=Subquery(
+                    CycleIssue.objects.filter(issue=OuterRef("id"), deleted_at__isnull=True).values("cycle_id")[:1]
+                )
+            )
+            .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")
+            )
+            .annotate(
+                sub_issues_count=Issue.issue_objects.filter(parent=OuterRef("id"))
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
+            .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())),
+                ),
+                module_ids=Coalesce(
+                    ArrayAgg(
+                        "issue_module__module_id",
+                        distinct=True,
+                        filter=Q(
+                            ~Q(issue_module__module_id__isnull=True)
+                            & Q(issue_module__module__archived_at__isnull=True)
+                            & Q(issue_module__deleted_at__isnull=True)
+                        ),
+                    ),
+                    Value([], output_field=ArrayField(UUIDField())),
+                ),
+            )
+        ).distinct()
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
+    def list(self, request, slug, project_id):
+        intake = Intake.objects.filter(workspace__slug=slug, project_id=project_id).first()
+        if not intake:
+            return Response({"error": "Intake not found"}, status=status.HTTP_404_NOT_FOUND)
+
+        project = Project.objects.get(pk=project_id)
+        filters = issue_filters(request.GET, "GET", "issue__")
+        intake_issue = (
+            IntakeIssue.objects.filter(intake_id=intake.id, project_id=project_id, **filters)
+            .select_related("issue")
+            .prefetch_related("issue__labels")
+            .annotate(
+                label_ids=Coalesce(
+                    ArrayAgg(
+                        "issue__labels__id",
+                        distinct=True,
+                        filter=Q(~Q(issue__labels__id__isnull=True) & Q(issue__label_issue__deleted_at__isnull=True)),
+                    ),
+                    Value([], output_field=ArrayField(UUIDField())),
+                )
+            )
+        ).order_by(request.GET.get("order_by", "-issue__created_at"))
+        # Intake status filter
+        intake_status = [item for item in request.GET.get("status", "-2").split(",") if item != "null"]
+        if intake_status:
+            intake_issue = intake_issue.filter(status__in=intake_status)
+
+        if (
+            ProjectMember.objects.filter(
+                workspace__slug=slug,
+                project_id=project_id,
+                member=request.user,
+                role=ROLE.GUEST.value,
+                is_active=True,
+            ).exists()
+            and not project.guest_view_all_features
+        ):
+            intake_issue = intake_issue.filter(created_by=request.user)
+        return self.paginate(
+            request=request,
+            queryset=(intake_issue),
+            on_results=lambda intake_issues: IntakeIssueSerializer(intake_issues, many=True).data,
+        )
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
+    def create(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)
+
+        # 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)
+
+        project = Project.objects.get(pk=project_id)
+
+        # get the triage state
+        triage_state = State.triage_objects.filter(project_id=project_id, workspace__slug=slug).first()
+        if not triage_state:
+            triage_state = State.objects.create(
+                name="Triage",
+                group=StateGroup.TRIAGE.value,
+                project_id=project_id,
+                workspace_id=project.workspace_id,
+                color="#4E5355",
+                sequence=65000,
+                default=False,
+            )
+        request.data["issue"]["state_id"] = triage_state.id
+
+        # create an issue
+        serializer = IssueCreateSerializer(
+            data=request.data.get("issue"),
+            context={
+                "project_id": project_id,
+                "workspace_id": project.workspace_id,
+                "default_assignee_id": project.default_assignee_id,
+                "allow_triage_state": True,
+            },
+        )
+        if serializer.is_valid():
+            serializer.save()
+            intake_id = Intake.objects.filter(workspace__slug=slug, project_id=project_id).first()
+            # create an intake issue
+            intake_issue = IntakeIssue.objects.create(
+                intake_id=intake_id.id,
+                project_id=project_id,
+                issue_id=serializer.data["id"],
+                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(serializer.data["id"]),
+                project_id=str(project_id),
+                current_instance=None,
+                epoch=int(timezone.now().timestamp()),
+                notification=True,
+                origin=base_host(request=request, is_app=True),
+                intake=str(intake_issue.id),
+            )
+            # updated issue description version
+            issue_description_version_task.delay(
+                updated_issue=json.dumps(request.data, cls=DjangoJSONEncoder),
+                issue_id=str(serializer.data["id"]),
+                user_id=request.user.id,
+                is_creating=True,
+            )
+            intake_issue = (
+                IntakeIssue.objects.select_related("issue")
+                .prefetch_related("issue__labels", "issue__assignees")
+                .annotate(
+                    label_ids=Coalesce(
+                        ArrayAgg(
+                            "issue__labels__id",
+                            distinct=True,
+                            filter=Q(
+                                ~Q(issue__labels__id__isnull=True) & Q(issue__label_issue__deleted_at__isnull=True)
+                            ),
+                        ),
+                        Value([], output_field=ArrayField(UUIDField())),
+                    ),
+                    assignee_ids=Coalesce(
+                        ArrayAgg(
+                            "issue__assignees__id",
+                            distinct=True,
+                            filter=~Q(issue__assignees__id__isnull=True)
+                            & Q(issue__assignees__member_project__is_active=True),
+                        ),
+                        Value([], output_field=ArrayField(UUIDField())),
+                    ),
+                )
+                .get(
+                    intake_id=intake_id.id,
+                    issue_id=serializer.data["id"],
+                    project_id=project_id,
+                )
+            )
+            serializer = IntakeIssueDetailSerializer(intake_issue)
+            return Response(serializer.data, status=status.HTTP_200_OK)
+        else:
+            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    @allow_permission(allowed_roles=[ROLE.ADMIN], creator=True, model=Issue)
+    def partial_update(self, request, slug, project_id, pk):
+        skip_activity = request.data.pop("skip_activity", False)
+        is_description_update = request.data.get("description_html") is not None
+
+        intake_id = Intake.objects.filter(workspace__slug=slug, project_id=project_id).first()
+        intake_issue = IntakeIssue.objects.get(
+            issue_id=pk,
+            workspace__slug=slug,
+            project_id=project_id,
+            intake_id=intake_id,
+        )
+
+        project_member = ProjectMember.objects.filter(
+            workspace__slug=slug,
+            project_id=project_id,
+            member=request.user,
+            is_active=True,
+        ).first()
+
+        is_workspace_admin = WorkspaceMember.objects.filter(
+            workspace__slug=slug,
+            is_active=True,
+            member=request.user,
+            role=ROLE.ADMIN.value,
+        ).exists()
+
+        if not project_member and not is_workspace_admin:
+            return Response(
+                {"error": "Only admin or creator can update the intake work items"},
+                status=status.HTTP_403_FORBIDDEN,
+            )
+
+        # Only project members admins and created_by users can access this endpoint
+        if ((project_member and project_member.role <= ROLE.GUEST.value) and not is_workspace_admin) 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)
+        issue_serializer = None
+        issue = None
+        issue_current_instance = None
+        issue_requested_data = None
+
+        # Validate issue data if provided
+        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(issue_assignee__deleted_at__isnull=True)),
+                    ),
+                    Value([], output_field=ArrayField(UUIDField())),
+                ),
+            ).get(pk=intake_issue.issue_id, workspace__slug=slug, project_id=project_id)
+
+            if project_member and project_member.role <= ROLE.GUEST.value:
+                issue_data = {
+                    "name": issue_data.get("name", issue.name),
+                    "description_html": issue_data.get("description_html", issue.description_html),
+                    "description_json": issue_data.get("description_json", issue.description_json),
+                }
+
+            issue_current_instance = json.dumps(IssueDetailSerializer(issue).data, cls=DjangoJSONEncoder)
+            issue_requested_data = json.dumps(issue_data, cls=DjangoJSONEncoder)
+
+            issue_serializer = IssueCreateSerializer(
+                issue, data=issue_data, partial=True, context={"project_id": project_id, "allow_triage_state": True}
+            )
+
+            if not issue_serializer.is_valid():
+                return Response(issue_serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+        # Validate intake issue data if user has permission
+        intake_serializer = None
+        intake_current_instance = None
+
+        if (project_member and project_member.role > ROLE.MEMBER.value) or is_workspace_admin:
+            intake_current_instance = json.dumps(IntakeIssueSerializer(intake_issue).data, cls=DjangoJSONEncoder)
+            intake_serializer = IntakeIssueSerializer(intake_issue, data=request.data, partial=True)
+
+            if not intake_serializer.is_valid():
+                return Response(intake_serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+        # Both serializers are valid, now save them
+        if issue_serializer:
+            issue_serializer.save()
+
+            # Check if the update is a migration description update
+            is_migration_description_update = skip_activity and is_description_update
+            # Log all the updates
+            if not is_migration_description_update:
+                if issue is not None:
+                    issue_activity.delay(
+                        type="issue.activity.updated",
+                        requested_data=issue_requested_data,
+                        actor_id=str(request.user.id),
+                        issue_id=str(issue.id),
+                        project_id=str(project_id),
+                        current_instance=issue_current_instance,
+                        epoch=int(timezone.now().timestamp()),
+                        notification=True,
+                        origin=base_host(request=request, is_app=True),
+                        intake=str(intake_issue.id),
+                    )
+                    # updated issue description version
+                    issue_description_version_task.delay(
+                        updated_issue=issue_current_instance,
+                        issue_id=str(pk),
+                        user_id=request.user.id,
+                    )
+
+        if intake_serializer:
+            intake_serializer.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(pk),
+                project_id=str(project_id),
+                current_instance=intake_current_instance,
+                epoch=int(timezone.now().timestamp()),
+                notification=False,
+                origin=base_host(request=request, is_app=True),
+                intake=str(intake_issue.id),
+            )
+
+        # Fetch and return the updated intake issue
+        intake_issue = (
+            IntakeIssue.objects.select_related("issue")
+            .prefetch_related("issue__labels", "issue__assignees")
+            .annotate(
+                label_ids=Coalesce(
+                    ArrayAgg(
+                        "issue__labels__id",
+                        distinct=True,
+                        filter=Q(~Q(issue__labels__id__isnull=True) & Q(issue__label_issue__deleted_at__isnull=True)),
+                    ),
+                    Value([], output_field=ArrayField(UUIDField())),
+                ),
+                assignee_ids=Coalesce(
+                    ArrayAgg(
+                        "issue__assignees__id",
+                        distinct=True,
+                        filter=Q(
+                            ~Q(issue__assignees__id__isnull=True) & Q(issue__issue_assignee__deleted_at__isnull=True)
+                        ),
+                    ),
+                    Value([], output_field=ArrayField(UUIDField())),
+                ),
+            )
+            .get(intake_id=intake_id.id, issue_id=pk, project_id=project_id)
+        )
+        serializer = IntakeIssueDetailSerializer(intake_issue).data
+        return Response(serializer, status=status.HTTP_200_OK)
+
+    @allow_permission(allowed_roles=[ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], creator=True, model=Issue)
+    def retrieve(self, request, slug, project_id, pk):
+        intake_id = Intake.objects.filter(workspace__slug=slug, project_id=project_id).first()
+        project = Project.objects.get(pk=project_id)
+        intake_issue = (
+            IntakeIssue.objects.select_related("issue")
+            .prefetch_related("issue__labels", "issue__assignees")
+            .annotate(
+                label_ids=Coalesce(
+                    ArrayAgg(
+                        "issue__labels__id",
+                        distinct=True,
+                        filter=Q(~Q(issue__labels__id__isnull=True) & Q(issue__label_issue__deleted_at__isnull=True)),
+                    ),
+                    Value([], output_field=ArrayField(UUIDField())),
+                ),
+                assignee_ids=Coalesce(
+                    ArrayAgg(
+                        "issue__assignees__id",
+                        distinct=True,
+                        filter=Q(
+                            ~Q(issue__assignees__id__isnull=True) & Q(issue__issue_assignee__deleted_at__isnull=True)
+                        ),
+                    ),
+                    Value([], output_field=ArrayField(UUIDField())),
+                ),
+            )
+            .get(intake_id=intake_id.id, issue_id=pk, project_id=project_id)
+        )
+        if (
+            ProjectMember.objects.filter(
+                workspace__slug=slug,
+                project_id=project_id,
+                member=request.user,
+                role=ROLE.GUEST.value,
+                is_active=True,
+            ).exists()
+            and not project.guest_view_all_features
+            and not intake_issue.created_by == request.user
+        ):
+            return Response(
+                {"error": "You are not allowed to view this issue"},
+                status=status.HTTP_403_FORBIDDEN,
+            )
+        issue = IntakeIssueDetailSerializer(intake_issue).data
+        return Response(issue, status=status.HTTP_200_OK)
+
+    @allow_permission(allowed_roles=[ROLE.ADMIN], creator=True, model=Issue)
+    def destroy(self, request, slug, project_id, pk):
+        intake_id = Intake.objects.filter(workspace__slug=slug, project_id=project_id).first()
+        intake_issue = IntakeIssue.objects.get(
+            issue_id=pk,
+            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=pk).first()
+            issue.delete()
+
+        intake_issue.delete()
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+class IntakeWorkItemDescriptionVersionEndpoint(BaseAPIView):
+    def process_paginated_result(self, fields, results, timezone):
+        paginated_data = results.values(*fields)
+
+        datetime_fields = ["created_at", "updated_at"]
+        paginated_data = user_timezone_converter(paginated_data, datetime_fields, timezone)
+
+        return paginated_data
+
+    @allow_permission(allowed_roles=[ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
+    def get(self, request, slug, project_id, work_item_id, pk=None):
+        project = Project.objects.get(pk=project_id)
+        issue = Issue.objects.get(workspace__slug=slug, project_id=project_id, pk=work_item_id)
+
+        if (
+            ProjectMember.objects.filter(
+                workspace__slug=slug,
+                project_id=project_id,
+                member=request.user,
+                role=ROLE.GUEST.value,
+                is_active=True,
+            ).exists()
+            and not project.guest_view_all_features
+            and not issue.created_by == request.user
+        ):
+            return Response(
+                {"error": "You are not allowed to view this issue"},
+                status=status.HTTP_403_FORBIDDEN,
+            )
+
+        if pk:
+            issue_description_version = IssueDescriptionVersion.objects.get(
+                workspace__slug=slug,
+                project_id=project_id,
+                issue_id=work_item_id,
+                pk=pk,
+            )
+
+            serializer = IssueDescriptionVersionDetailSerializer(issue_description_version)
+            return Response(serializer.data, status=status.HTTP_200_OK)
+
+        cursor = request.GET.get("cursor", None)
+
+        required_fields = [
+            "id",
+            "workspace",
+            "project",
+            "issue",
+            "last_saved_at",
+            "owned_by",
+            "created_at",
+            "updated_at",
+            "created_by",
+            "updated_by",
+        ]
+
+        issue_description_versions_queryset = IssueDescriptionVersion.objects.filter(
+            workspace__slug=slug, project_id=project_id, issue_id=work_item_id
+        )
+
+        paginated_data = paginate(
+            base_queryset=issue_description_versions_queryset,
+            queryset=issue_description_versions_queryset,
+            cursor=cursor,
+            on_result=lambda results: self.process_paginated_result(
+                required_fields, results, request.user.user_timezone
+            ),
+        )
+        return Response(paginated_data, status=status.HTTP_200_OK)

plane-src/apps/api/plane/app/views/issue/activity.py

@@ -0,0 +1,86 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+# Python imports
+from itertools import chain
+
+# Django imports
+from django.db.models import Prefetch, Q
+from django.utils.decorators import method_decorator
+from django.views.decorators.gzip import gzip_page
+
+# Third Party imports
+from rest_framework.response import Response
+from rest_framework import status
+
+# Module imports
+from .. import BaseAPIView
+from plane.app.serializers import IssueActivitySerializer, IssueCommentSerializer
+from plane.app.permissions import ProjectEntityPermission, allow_permission, ROLE
+from plane.db.models import IssueActivity, IssueComment, CommentReaction, IntakeIssue
+
+
+class IssueActivityEndpoint(BaseAPIView):
+    permission_classes = [ProjectEntityPermission]
+    use_read_replica = True
+
+    @method_decorator(gzip_page)
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
+    def get(self, request, slug, project_id, issue_id):
+        filters = {}
+        if request.GET.get("created_at__gt", None) is not None:
+            filters = {"created_at__gt": request.GET.get("created_at__gt")}
+
+        issue_activities = (
+            IssueActivity.objects.filter(issue_id=issue_id)
+            .filter(
+                ~Q(field__in=["comment", "vote", "reaction", "draft"]),
+                project__project_projectmember__member=self.request.user,
+                project__project_projectmember__is_active=True,
+                project__archived_at__isnull=True,
+                workspace__slug=slug,
+            )
+            .filter(**filters)
+            .select_related("actor", "workspace", "issue", "project")
+        ).order_by("created_at")
+        issue_comments = (
+            IssueComment.objects.filter(issue_id=issue_id)
+            .filter(
+                project__project_projectmember__member=self.request.user,
+                project__project_projectmember__is_active=True,
+                project__archived_at__isnull=True,
+                workspace__slug=slug,
+            )
+            .filter(**filters)
+            .order_by("created_at")
+            .select_related("actor", "issue", "project", "workspace")
+            .prefetch_related(
+                Prefetch(
+                    "comment_reactions",
+                    queryset=CommentReaction.objects.select_related("actor"),
+                )
+            )
+        )
+
+        if request.GET.get("activity_type", None) == "issue-property":
+            issue_activities = issue_activities.prefetch_related(
+                Prefetch(
+                    "issue__issue_intake",
+                    queryset=IntakeIssue.objects.only("source_email", "source", "extra"),
+                    to_attr="source_data",
+                )
+            )
+            issue_activities = IssueActivitySerializer(issue_activities, many=True).data
+            return Response(issue_activities, status=status.HTTP_200_OK)
+
+        if request.GET.get("activity_type", None) == "issue-comment":
+            issue_comments = IssueCommentSerializer(issue_comments, many=True).data
+            return Response(issue_comments, status=status.HTTP_200_OK)
+
+        result_list = sorted(
+            chain(issue_activities, issue_comments),
+            key=lambda instance: instance["created_at"],
+        )
+
+        return Response(result_list, status=status.HTTP_200_OK)

plane-src/apps/api/plane/app/views/issue/archive.py

@@ -0,0 +1,343 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+# Python imports
+import copy
+import json
+
+# Django imports
+from django.core.serializers.json import DjangoJSONEncoder
+from django.db.models import OuterRef, Q, Prefetch, Exists, Subquery, Count
+from django.utils import timezone
+from django.utils.decorators import method_decorator
+from django.views.decorators.gzip import gzip_page
+
+# Third Party imports
+from rest_framework import status
+from rest_framework.response import Response
+
+from plane.app.permissions import ProjectEntityPermission
+from plane.app.serializers import (
+    IssueFlatSerializer,
+    IssueSerializer,
+    IssueDetailSerializer,
+)
+from plane.bgtasks.issue_activities_task import issue_activity
+from plane.db.models import (
+    Issue,
+    FileAsset,
+    IssueLink,
+    IssueSubscriber,
+    IssueReaction,
+    CycleIssue,
+)
+from plane.utils.grouper import (
+    issue_group_values,
+    issue_on_results,
+    issue_queryset_grouper,
+)
+from plane.utils.issue_filters import issue_filters
+from plane.utils.order_queryset import order_issue_queryset
+from plane.utils.paginator import GroupedOffsetPaginator, SubGroupedOffsetPaginator
+from plane.app.permissions import allow_permission, ROLE
+from plane.utils.error_codes import ERROR_CODES
+from plane.utils.host import base_host
+
+# Module imports
+from .. import BaseViewSet, BaseAPIView
+from plane.utils.filters import ComplexFilterBackend
+from plane.utils.filters import IssueFilterSet
+
+
+class IssueArchiveViewSet(BaseViewSet):
+    serializer_class = IssueFlatSerializer
+    model = Issue
+
+    filter_backends = (ComplexFilterBackend,)
+    filterset_class = IssueFilterSet
+
+    def apply_annotations(self, issues):
+        return (
+            issues.annotate(
+                cycle_id=Subquery(
+                    CycleIssue.objects.filter(issue=OuterRef("id"), deleted_at__isnull=True).values("cycle_id")[:1]
+                )
+            )
+            .annotate(
+                link_count=Subquery(
+                    IssueLink.objects.filter(issue=OuterRef("id"))
+                    .values("issue")
+                    .annotate(count=Count("id"))
+                    .values("count")
+                )
+            )
+            .annotate(
+                attachment_count=Subquery(
+                    FileAsset.objects.filter(
+                        issue_id=OuterRef("id"),
+                        entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
+                    )
+                    .values("issue_id")
+                    .annotate(count=Count("id"))
+                    .values("count")
+                )
+            )
+            .annotate(
+                sub_issues_count=Subquery(
+                    Issue.issue_objects.filter(parent=OuterRef("id"))
+                    .values("parent")
+                    .annotate(count=Count("id"))
+                    .values("count")
+                )
+            )
+            .prefetch_related("assignees", "labels", "issue_module__module")
+        )
+
+    def get_queryset(self):
+        return (
+            Issue.objects.filter(Q(type__isnull=True) | Q(type__is_epic=False))
+            .filter(archived_at__isnull=False)
+            .filter(project_id=self.kwargs.get("project_id"))
+            .filter(workspace__slug=self.kwargs.get("slug"))
+        )
+
+    @method_decorator(gzip_page)
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
+    def list(self, request, slug, project_id):
+        filters = issue_filters(request.query_params, "GET")
+        show_sub_issues = request.GET.get("show_sub_issues", "true")
+
+        order_by_param = request.GET.get("order_by", "-created_at")
+
+        issue_queryset = self.get_queryset()
+
+        issue_queryset = issue_queryset if show_sub_issues == "true" else issue_queryset.filter(parent__isnull=True)
+        # Apply filtering from filterset
+        issue_queryset = self.filter_queryset(issue_queryset)
+
+        # Apply legacy filters
+        issue_queryset = issue_queryset.filter(**filters)
+
+        # Total count queryset
+        total_issue_queryset = copy.deepcopy(issue_queryset)
+
+        # Applying annotations to the issue queryset
+        issue_queryset = self.apply_annotations(issue_queryset)
+
+        # Issue queryset
+        issue_queryset, order_by_param = order_issue_queryset(
+            issue_queryset=issue_queryset, order_by_param=order_by_param
+        )
+
+        # Group by
+        group_by = request.GET.get("group_by", False)
+        sub_group_by = request.GET.get("sub_group_by", False)
+
+        # issue queryset
+        issue_queryset = issue_queryset_grouper(queryset=issue_queryset, group_by=group_by, sub_group_by=sub_group_by)
+
+        if group_by:
+            # Check group and sub group value paginate
+            if sub_group_by:
+                if group_by == sub_group_by:
+                    return Response(
+                        {"error": "Group by and sub group by cannot have same parameters"},
+                        status=status.HTTP_400_BAD_REQUEST,
+                    )
+                else:
+                    # group and sub group pagination
+                    return self.paginate(
+                        request=request,
+                        order_by=order_by_param,
+                        queryset=issue_queryset,
+                        total_count_queryset=total_issue_queryset,
+                        on_results=lambda issues: issue_on_results(
+                            group_by=group_by, issues=issues, sub_group_by=sub_group_by
+                        ),
+                        paginator_cls=SubGroupedOffsetPaginator,
+                        group_by_fields=issue_group_values(
+                            field=group_by,
+                            slug=slug,
+                            project_id=project_id,
+                            filters=filters,
+                        ),
+                        sub_group_by_fields=issue_group_values(
+                            field=sub_group_by,
+                            slug=slug,
+                            project_id=project_id,
+                            filters=filters,
+                        ),
+                        group_by_field_name=group_by,
+                        sub_group_by_field_name=sub_group_by,
+                        count_filter=Q(
+                            Q(issue_intake__status=1)
+                            | Q(issue_intake__status=-1)
+                            | Q(issue_intake__status=2)
+                            | Q(issue_intake__isnull=True),
+                            archived_at__isnull=True,
+                            is_draft=False,
+                        ),
+                    )
+            # Group Paginate
+            else:
+                # Group paginate
+                return self.paginate(
+                    request=request,
+                    order_by=order_by_param,
+                    queryset=issue_queryset,
+                    total_count_queryset=total_issue_queryset,
+                    on_results=lambda issues: issue_on_results(
+                        group_by=group_by, issues=issues, sub_group_by=sub_group_by
+                    ),
+                    paginator_cls=GroupedOffsetPaginator,
+                    group_by_fields=issue_group_values(
+                        field=group_by,
+                        slug=slug,
+                        project_id=project_id,
+                        filters=filters,
+                    ),
+                    group_by_field_name=group_by,
+                    count_filter=Q(
+                        Q(issue_intake__status=1)
+                        | Q(issue_intake__status=-1)
+                        | Q(issue_intake__status=2)
+                        | Q(issue_intake__isnull=True),
+                        archived_at__isnull=True,
+                        is_draft=False,
+                    ),
+                )
+        else:
+            # List Paginate
+            return self.paginate(
+                order_by=order_by_param,
+                request=request,
+                queryset=issue_queryset,
+                total_count_queryset=total_issue_queryset,
+                on_results=lambda issues: issue_on_results(group_by=group_by, issues=issues, sub_group_by=sub_group_by),
+            )
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
+    def retrieve(self, request, slug, project_id, pk=None):
+        issue = (
+            self.get_queryset()
+            .filter(pk=pk)
+            .prefetch_related(
+                Prefetch(
+                    "issue_reactions",
+                    queryset=IssueReaction.objects.select_related("issue", "actor"),
+                )
+            )
+            .prefetch_related(
+                Prefetch(
+                    "issue_link",
+                    queryset=IssueLink.objects.select_related("created_by"),
+                )
+            )
+            .annotate(
+                is_subscribed=Exists(
+                    IssueSubscriber.objects.filter(
+                        workspace__slug=slug,
+                        project_id=project_id,
+                        issue_id=OuterRef("pk"),
+                        subscriber=request.user,
+                    )
+                )
+            )
+        ).first()
+        if not issue:
+            return Response(
+                {"error": "The required object does not exist."},
+                status=status.HTTP_404_NOT_FOUND,
+            )
+        serializer = IssueDetailSerializer(issue, expand=self.expand)
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
+    def archive(self, request, slug, project_id, pk=None):
+        issue = Issue.issue_objects.get(workspace__slug=slug, project_id=project_id, pk=pk)
+        if issue.state.group not in ["completed", "cancelled"]:
+            return Response(
+                {"error": "Can only archive completed or cancelled state group issue"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+        issue_activity.delay(
+            type="issue.activity.updated",
+            requested_data=json.dumps({"archived_at": str(timezone.now().date()), "automation": False}),
+            actor_id=str(request.user.id),
+            issue_id=str(issue.id),
+            project_id=str(project_id),
+            current_instance=json.dumps(IssueSerializer(issue).data, cls=DjangoJSONEncoder),
+            epoch=int(timezone.now().timestamp()),
+            notification=True,
+            origin=base_host(request=request, is_app=True),
+        )
+        issue.archived_at = timezone.now().date()
+        issue.save()
+
+        return Response({"archived_at": str(issue.archived_at)}, status=status.HTTP_200_OK)
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
+    def unarchive(self, request, slug, project_id, pk=None):
+        issue = Issue.objects.get(
+            workspace__slug=slug,
+            project_id=project_id,
+            archived_at__isnull=False,
+            pk=pk,
+        )
+        issue_activity.delay(
+            type="issue.activity.updated",
+            requested_data=json.dumps({"archived_at": None}),
+            actor_id=str(request.user.id),
+            issue_id=str(issue.id),
+            project_id=str(project_id),
+            current_instance=json.dumps(IssueSerializer(issue).data, cls=DjangoJSONEncoder),
+            epoch=int(timezone.now().timestamp()),
+            notification=True,
+            origin=base_host(request=request, is_app=True),
+        )
+        issue.archived_at = None
+        issue.save()
+
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+class BulkArchiveIssuesEndpoint(BaseAPIView):
+    permission_classes = [ProjectEntityPermission]
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
+    def post(self, request, slug, project_id):
+        issue_ids = request.data.get("issue_ids", [])
+
+        if not len(issue_ids):
+            return Response({"error": "Issue IDs are required"}, status=status.HTTP_400_BAD_REQUEST)
+
+        issues = Issue.objects.filter(workspace__slug=slug, project_id=project_id, pk__in=issue_ids).select_related(
+            "state"
+        )
+        bulk_archive_issues = []
+        for issue in issues:
+            if issue.state.group not in ["completed", "cancelled"]:
+                return Response(
+                    {
+                        "error_code": ERROR_CODES["INVALID_ARCHIVE_STATE_GROUP"],
+                        "error_message": "INVALID_ARCHIVE_STATE_GROUP",
+                    },
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+            issue_activity.delay(
+                type="issue.activity.updated",
+                requested_data=json.dumps({"archived_at": str(timezone.now().date()), "automation": False}),
+                actor_id=str(request.user.id),
+                issue_id=str(issue.id),
+                project_id=str(project_id),
+                current_instance=json.dumps(IssueSerializer(issue).data, cls=DjangoJSONEncoder),
+                epoch=int(timezone.now().timestamp()),
+                notification=True,
+                origin=base_host(request=request, is_app=True),
+            )
+            issue.archived_at = timezone.now().date()
+            bulk_archive_issues.append(issue)
+        Issue.objects.bulk_update(bulk_archive_issues, ["archived_at"])
+
+        return Response({"archived_at": str(timezone.now().date())}, status=status.HTTP_200_OK)

plane-src/apps/api/plane/app/views/issue/attachment.py

@@ -0,0 +1,229 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+# Python imports
+import json
+import uuid
+
+# Django imports
+from django.utils import timezone
+from django.core.serializers.json import DjangoJSONEncoder
+from django.conf import settings
+from django.http import HttpResponseRedirect
+
+# Third Party imports
+from rest_framework.response import Response
+from rest_framework import status
+from rest_framework.parsers import MultiPartParser, FormParser
+
+# Module imports
+from .. import BaseAPIView
+from plane.app.serializers import IssueAttachmentSerializer
+from plane.db.models import FileAsset, Workspace
+from plane.bgtasks.issue_activities_task import issue_activity
+from plane.app.permissions import allow_permission, ROLE
+from plane.settings.storage import S3Storage
+from plane.bgtasks.storage_metadata_task import get_asset_object_metadata
+from plane.utils.host import base_host
+
+
+class IssueAttachmentEndpoint(BaseAPIView):
+    serializer_class = IssueAttachmentSerializer
+    model = FileAsset
+    parser_classes = (MultiPartParser, FormParser)
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
+    def post(self, request, slug, project_id, issue_id):
+        serializer = IssueAttachmentSerializer(data=request.data)
+        workspace = Workspace.objects.get(slug=slug)
+        if serializer.is_valid():
+            serializer.save(
+                project_id=project_id,
+                issue_id=issue_id,
+                workspace_id=workspace.id,
+                entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
+            )
+            issue_activity.delay(
+                type="attachment.activity.created",
+                requested_data=None,
+                actor_id=str(self.request.user.id),
+                issue_id=str(self.kwargs.get("issue_id", None)),
+                project_id=str(self.kwargs.get("project_id", None)),
+                current_instance=json.dumps(serializer.data, cls=DjangoJSONEncoder),
+                epoch=int(timezone.now().timestamp()),
+                notification=True,
+                origin=base_host(request=request, is_app=True),
+            )
+            return Response(serializer.data, status=status.HTTP_201_CREATED)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    @allow_permission([ROLE.ADMIN], creator=True, model=FileAsset)
+    def delete(self, request, slug, project_id, issue_id, pk):
+        issue_attachment = FileAsset.objects.filter(
+            pk=pk, workspace__slug=slug, project_id=project_id, issue_id=issue_id
+        ).first()
+        if not issue_attachment:
+            return Response(
+                {"error": "Issue attachment not found."},
+                status=status.HTTP_404_NOT_FOUND,
+            )
+        issue_attachment.asset.delete(save=False)
+        issue_attachment.delete()
+        issue_activity.delay(
+            type="attachment.activity.deleted",
+            requested_data=None,
+            actor_id=str(self.request.user.id),
+            issue_id=str(self.kwargs.get("issue_id", None)),
+            project_id=str(self.kwargs.get("project_id", None)),
+            current_instance=None,
+            epoch=int(timezone.now().timestamp()),
+            notification=True,
+            origin=base_host(request=request, is_app=True),
+        )
+
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
+    def get(self, request, slug, project_id, issue_id):
+        issue_attachments = FileAsset.objects.filter(issue_id=issue_id, workspace__slug=slug, project_id=project_id)
+        serializer = IssueAttachmentSerializer(issue_attachments, many=True)
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+
+class IssueAttachmentV2Endpoint(BaseAPIView):
+    serializer_class = IssueAttachmentSerializer
+    model = FileAsset
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
+    def post(self, request, slug, project_id, issue_id):
+        name = request.data.get("name")
+        type = request.data.get("type", False)
+        size = int(request.data.get("size", settings.FILE_SIZE_LIMIT))
+
+        if not type or type not in settings.ATTACHMENT_MIME_TYPES:
+            return Response(
+                {"error": "Invalid file type.", "status": False},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # Get the workspace
+        workspace = Workspace.objects.get(slug=slug)
+
+        # asset key
+        asset_key = f"{workspace.id}/{uuid.uuid4().hex}-{name}"
+
+        # Get the size limit
+        size_limit = min(size, settings.FILE_SIZE_LIMIT)
+
+        # Create a File Asset
+        asset = FileAsset.objects.create(
+            attributes={"name": name, "type": type, "size": size_limit},
+            asset=asset_key,
+            size=size_limit,
+            workspace_id=workspace.id,
+            created_by=request.user,
+            issue_id=issue_id,
+            project_id=project_id,
+            entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
+        )
+
+        # Get the presigned URL
+        storage = S3Storage(request=request)
+
+        # Generate a presigned URL to share an S3 object
+        presigned_url = storage.generate_presigned_post(object_name=asset_key, file_type=type, file_size=size_limit)
+
+        # Return the presigned URL
+        return Response(
+            {
+                "upload_data": presigned_url,
+                "asset_id": str(asset.id),
+                "attachment": IssueAttachmentSerializer(asset).data,
+                "asset_url": asset.asset_url,
+            },
+            status=status.HTTP_200_OK,
+        )
+
+    @allow_permission([ROLE.ADMIN], creator=True, model=FileAsset)
+    def delete(self, request, slug, project_id, issue_id, pk):
+        issue_attachment = FileAsset.objects.get(pk=pk, workspace__slug=slug, project_id=project_id)
+        issue_attachment.is_deleted = True
+        issue_attachment.deleted_at = timezone.now()
+        issue_attachment.save()
+
+        issue_activity.delay(
+            type="attachment.activity.deleted",
+            requested_data=None,
+            actor_id=str(self.request.user.id),
+            issue_id=str(issue_id),
+            project_id=str(project_id),
+            current_instance=None,
+            epoch=int(timezone.now().timestamp()),
+            notification=True,
+            origin=base_host(request=request, is_app=True),
+        )
+
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
+    def get(self, request, slug, project_id, issue_id, pk=None):
+        if pk:
+            # Get the asset
+            asset = FileAsset.objects.get(id=pk, workspace__slug=slug, project_id=project_id)
+
+            # Check if the asset is uploaded
+            if not asset.is_uploaded:
+                return Response(
+                    {"error": "The asset is not uploaded.", "status": False},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+            storage = S3Storage(request=request)
+            presigned_url = storage.generate_presigned_url(
+                object_name=asset.asset.name,
+                disposition="attachment",
+                filename=asset.attributes.get("name"),
+            )
+            return HttpResponseRedirect(presigned_url)
+
+        # Get all the attachments
+        issue_attachments = FileAsset.objects.filter(
+            issue_id=issue_id,
+            entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
+            workspace__slug=slug,
+            project_id=project_id,
+            is_uploaded=True,
+        )
+        # Serialize the attachments
+        serializer = IssueAttachmentSerializer(issue_attachments, many=True)
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
+    def patch(self, request, slug, project_id, issue_id, pk):
+        issue_attachment = FileAsset.objects.get(pk=pk, workspace__slug=slug, project_id=project_id)
+        serializer = IssueAttachmentSerializer(issue_attachment)
+
+        # Send this activity only if the attachment is not uploaded before
+        if not issue_attachment.is_uploaded:
+            issue_activity.delay(
+                type="attachment.activity.created",
+                requested_data=None,
+                actor_id=str(self.request.user.id),
+                issue_id=str(self.kwargs.get("issue_id", None)),
+                project_id=str(self.kwargs.get("project_id", None)),
+                current_instance=json.dumps(serializer.data, cls=DjangoJSONEncoder),
+                epoch=int(timezone.now().timestamp()),
+                notification=True,
+                origin=base_host(request=request, is_app=True),
+            )
+
+            # Update the attachment
+            issue_attachment.is_uploaded = True
+            issue_attachment.created_by = request.user
+
+        # Get the storage metadata
+        if not issue_attachment.storage_metadata:
+            get_asset_object_metadata.delay(str(issue_attachment.id))
+        issue_attachment.save()
+        return Response(status=status.HTTP_204_NO_CONTENT)

plane-src/apps/api/plane/app/views/issue/comment.py

@@ -0,0 +1,239 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+# Python imports
+import json
+
+# Django imports
+from django.utils import timezone
+from django.db.models import Exists
+from django.core.serializers.json import DjangoJSONEncoder
+from django.db import IntegrityError
+
+# Third Party imports
+from rest_framework.response import Response
+from rest_framework import status
+
+# Module imports
+from .. import BaseViewSet
+from plane.app.serializers import IssueCommentSerializer, CommentReactionSerializer
+from plane.app.permissions import allow_permission, ROLE
+from plane.db.models import IssueComment, ProjectMember, CommentReaction, Project, Issue
+from plane.bgtasks.issue_activities_task import issue_activity
+from plane.utils.host import base_host
+from plane.bgtasks.webhook_task import model_activity
+
+
+class IssueCommentViewSet(BaseViewSet):
+    serializer_class = IssueCommentSerializer
+    model = IssueComment
+    webhook_event = "issue_comment"
+
+    filterset_fields = ["issue__id", "workspace__id"]
+
+    def get_queryset(self):
+        return self.filter_queryset(
+            super()
+            .get_queryset()
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .filter(project_id=self.kwargs.get("project_id"))
+            .filter(issue_id=self.kwargs.get("issue_id"))
+            .filter(
+                project__project_projectmember__member=self.request.user,
+                project__project_projectmember__is_active=True,
+                project__archived_at__isnull=True,
+            )
+            .select_related("project")
+            .select_related("workspace")
+            .select_related("issue")
+            .annotate(
+                is_member=Exists(
+                    ProjectMember.objects.filter(
+                        workspace__slug=self.kwargs.get("slug"),
+                        project_id=self.kwargs.get("project_id"),
+                        member_id=self.request.user.id,
+                        is_active=True,
+                    )
+                )
+            )
+            .distinct()
+        )
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
+    def create(self, request, slug, project_id, issue_id):
+        project = Project.objects.get(pk=project_id)
+        issue = Issue.objects.get(pk=issue_id)
+        if (
+            ProjectMember.objects.filter(
+                workspace__slug=slug,
+                project_id=project_id,
+                member=request.user,
+                role=5,
+                is_active=True,
+            ).exists()
+            and not project.guest_view_all_features
+            and not issue.created_by == request.user
+        ):
+            return Response(
+                {"error": "You are not allowed to comment on the issue"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+        serializer = IssueCommentSerializer(data=request.data)
+        if serializer.is_valid():
+            serializer.save(project_id=project_id, issue_id=issue_id, actor=request.user)
+            issue_activity.delay(
+                type="comment.activity.created",
+                requested_data=json.dumps(serializer.data, cls=DjangoJSONEncoder),
+                actor_id=str(self.request.user.id),
+                issue_id=str(self.kwargs.get("issue_id")),
+                project_id=str(self.kwargs.get("project_id")),
+                current_instance=None,
+                epoch=int(timezone.now().timestamp()),
+                notification=True,
+                origin=base_host(request=request, is_app=True),
+            )
+            # Send the model activity
+            model_activity.delay(
+                model_name="issue_comment",
+                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),
+            )
+            return Response(serializer.data, status=status.HTTP_201_CREATED)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    @allow_permission(allowed_roles=[ROLE.ADMIN], creator=True, model=IssueComment)
+    def partial_update(self, request, slug, project_id, issue_id, pk):
+        issue_comment = IssueComment.objects.get(workspace__slug=slug, project_id=project_id, issue_id=issue_id, pk=pk)
+        requested_data = json.dumps(self.request.data, cls=DjangoJSONEncoder)
+        current_instance = json.dumps(IssueCommentSerializer(issue_comment).data, cls=DjangoJSONEncoder)
+        serializer = IssueCommentSerializer(issue_comment, data=request.data, partial=True)
+        if serializer.is_valid():
+            if "comment_html" in request.data and request.data["comment_html"] != issue_comment.comment_html:
+                serializer.save(edited_at=timezone.now())
+            else:
+                serializer.save()
+            issue_activity.delay(
+                type="comment.activity.updated",
+                requested_data=requested_data,
+                actor_id=str(request.user.id),
+                issue_id=str(issue_id),
+                project_id=str(project_id),
+                current_instance=current_instance,
+                epoch=int(timezone.now().timestamp()),
+                notification=True,
+                origin=base_host(request=request, is_app=True),
+            )
+            # Send the model activity
+            model_activity.delay(
+                model_name="issue_comment",
+                model_id=str(pk),
+                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)
+
+    @allow_permission(allowed_roles=[ROLE.ADMIN], creator=True, model=IssueComment)
+    def destroy(self, request, slug, project_id, issue_id, pk):
+        issue_comment = IssueComment.objects.get(workspace__slug=slug, project_id=project_id, issue_id=issue_id, pk=pk)
+        current_instance = json.dumps(IssueCommentSerializer(issue_comment).data, cls=DjangoJSONEncoder)
+        issue_comment.delete()
+        issue_activity.delay(
+            type="comment.activity.deleted",
+            requested_data=json.dumps({"comment_id": str(pk)}),
+            actor_id=str(request.user.id),
+            issue_id=str(issue_id),
+            project_id=str(project_id),
+            current_instance=current_instance,
+            epoch=int(timezone.now().timestamp()),
+            notification=True,
+            origin=base_host(request=request, is_app=True),
+        )
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+class CommentReactionViewSet(BaseViewSet):
+    serializer_class = CommentReactionSerializer
+    model = CommentReaction
+
+    def get_queryset(self):
+        return (
+            super()
+            .get_queryset()
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .filter(project_id=self.kwargs.get("project_id"))
+            .filter(comment_id=self.kwargs.get("comment_id"))
+            .filter(
+                project__project_projectmember__member=self.request.user,
+                project__project_projectmember__is_active=True,
+                project__archived_at__isnull=True,
+            )
+            .order_by("-created_at")
+            .distinct()
+        )
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
+    def create(self, request, slug, project_id, comment_id):
+        try:
+            serializer = CommentReactionSerializer(data=request.data)
+            if serializer.is_valid():
+                serializer.save(
+                    project_id=project_id,
+                    actor_id=request.user.id,
+                    comment_id=comment_id,
+                )
+                issue_activity.delay(
+                    type="comment_reaction.activity.created",
+                    requested_data=json.dumps(request.data, cls=DjangoJSONEncoder),
+                    actor_id=str(request.user.id),
+                    issue_id=None,
+                    project_id=str(project_id),
+                    current_instance=None,
+                    epoch=int(timezone.now().timestamp()),
+                    notification=True,
+                    origin=base_host(request=request, is_app=True),
+                )
+                return Response(serializer.data, status=status.HTTP_201_CREATED)
+            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+        except IntegrityError:
+            return Response(
+                {"error": "Reaction already exists for the user"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
+    def destroy(self, request, slug, project_id, comment_id, reaction_code):
+        comment_reaction = CommentReaction.objects.get(
+            workspace__slug=slug,
+            project_id=project_id,
+            comment_id=comment_id,
+            reaction=reaction_code,
+            actor=request.user,
+        )
+        issue_activity.delay(
+            type="comment_reaction.activity.deleted",
+            requested_data=None,
+            actor_id=str(self.request.user.id),
+            issue_id=None,
+            project_id=str(self.kwargs.get("project_id", None)),
+            current_instance=json.dumps(
+                {
+                    "reaction": str(reaction_code),
+                    "identifier": str(comment_reaction.id),
+                    "comment_id": str(comment_id),
+                }
+            ),
+            epoch=int(timezone.now().timestamp()),
+            notification=True,
+            origin=base_host(request=request, is_app=True),
+        )
+        comment_reaction.delete()
+        return Response(status=status.HTTP_204_NO_CONTENT)

plane-src/apps/api/plane/app/views/issue/label.py

@@ -0,0 +1,117 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+# Python imports
+import random
+
+# Django imports
+from django.db import IntegrityError
+
+# Third Party imports
+from rest_framework.response import Response
+from rest_framework import status
+
+# Module imports
+from .. import BaseViewSet, BaseAPIView
+from plane.app.serializers import LabelSerializer
+from plane.app.permissions import allow_permission, ProjectBasePermission, ROLE
+from plane.db.models import Project, Label
+from plane.utils.cache import invalidate_cache
+
+
+class LabelViewSet(BaseViewSet):
+    serializer_class = LabelSerializer
+    model = Label
+    permission_classes = [ProjectBasePermission]
+
+    def get_queryset(self):
+        return self.filter_queryset(
+            super()
+            .get_queryset()
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .filter(project_id=self.kwargs.get("project_id"))
+            .filter(project__project_projectmember__member=self.request.user)
+            .select_related("project")
+            .select_related("workspace")
+            .select_related("parent")
+            .distinct()
+            .order_by("sort_order")
+        )
+
+    @invalidate_cache(path="/api/workspaces/:slug/labels/", url_params=True, user=False, multiple=True)
+    @allow_permission([ROLE.ADMIN])
+    def create(self, request, slug, project_id):
+        try:
+            serializer = LabelSerializer(data=request.data, context={"project_id": project_id})
+            if serializer.is_valid():
+                serializer.save(project_id=project_id)
+                return Response(serializer.data, status=status.HTTP_201_CREATED)
+            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+        except IntegrityError:
+            return Response(
+                {"error": "Label with the same name already exists in the project"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+    @invalidate_cache(path="/api/workspaces/:slug/labels/", url_params=True, user=False)
+    @allow_permission([ROLE.ADMIN])
+    def partial_update(self, request, *args, **kwargs):
+        # Check if the label name is unique within the project
+        if (
+            "name" in request.data
+            and Label.objects.filter(project_id=kwargs["project_id"], name=request.data["name"])
+            .exclude(pk=kwargs["pk"])
+            .exists()
+        ):
+            return Response(
+                {"error": "Label with the same name already exists in the project"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        serializer = LabelSerializer(
+            instance=self.get_object(),
+            data=request.data,
+            context={"project_id": kwargs["project_id"]},
+            partial=True,
+        )
+
+        if serializer.is_valid():
+            serializer.save()
+            return Response(serializer.data)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    @invalidate_cache(path="/api/workspaces/:slug/labels/", url_params=True, user=False)
+    @allow_permission([ROLE.ADMIN])
+    def destroy(self, request, *args, **kwargs):
+        return super().destroy(request, *args, **kwargs)
+
+
+class BulkCreateIssueLabelsEndpoint(BaseAPIView):
+    @allow_permission([ROLE.ADMIN])
+    def post(self, request, slug, project_id):
+        label_data = request.data.get("label_data", [])
+
+        project = Project.objects.get(pk=project_id)
+
+        labels = Label.objects.bulk_create(
+            [
+                Label(
+                    name=label.get("name", "Migrated"),
+                    description=label.get("description", "Migrated Issue"),
+                    color=f"#{random.randint(0, 0xFFFFFF + 1):06X}",
+                    project_id=project_id,
+                    workspace_id=project.workspace_id,
+                    created_by=request.user,
+                    updated_by=request.user,
+                )
+                for label in label_data
+            ],
+            batch_size=50,
+            ignore_conflicts=True,
+        )
+
+        return Response(
+            {"labels": LabelSerializer(labels, many=True).data},
+            status=status.HTTP_201_CREATED,
+        )

plane-src/apps/api/plane/app/views/issue/link.py

@@ -0,0 +1,113 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+# Python imports
+import json
+
+# Django imports
+from django.utils import timezone
+from django.core.serializers.json import DjangoJSONEncoder
+
+# Third Party imports
+from rest_framework.response import Response
+from rest_framework import status
+
+# Module imports
+from .. import BaseViewSet
+from plane.app.serializers import IssueLinkSerializer
+from plane.app.permissions import ProjectEntityPermission
+from plane.db.models import IssueLink
+from plane.bgtasks.issue_activities_task import issue_activity
+from plane.bgtasks.work_item_link_task import crawl_work_item_link_title
+from plane.utils.host import base_host
+
+
+class IssueLinkViewSet(BaseViewSet):
+    permission_classes = [ProjectEntityPermission]
+
+    model = IssueLink
+    serializer_class = IssueLinkSerializer
+
+    def get_queryset(self):
+        return (
+            super()
+            .get_queryset()
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .filter(project_id=self.kwargs.get("project_id"))
+            .filter(issue_id=self.kwargs.get("issue_id"))
+            .filter(
+                project__project_projectmember__member=self.request.user,
+                project__project_projectmember__is_active=True,
+                project__archived_at__isnull=True,
+            )
+            .order_by("-created_at")
+            .distinct()
+        )
+
+    def create(self, request, slug, project_id, issue_id):
+        serializer = IssueLinkSerializer(data=request.data)
+        if serializer.is_valid():
+            serializer.save(project_id=project_id, issue_id=issue_id)
+            crawl_work_item_link_title.delay(serializer.data.get("id"), serializer.data.get("url"))
+            issue_activity.delay(
+                type="link.activity.created",
+                requested_data=json.dumps(serializer.data, cls=DjangoJSONEncoder),
+                actor_id=str(self.request.user.id),
+                issue_id=str(self.kwargs.get("issue_id")),
+                project_id=str(self.kwargs.get("project_id")),
+                current_instance=None,
+                epoch=int(timezone.now().timestamp()),
+                notification=True,
+                origin=base_host(request=request, is_app=True),
+            )
+
+            issue_link = self.get_queryset().get(id=serializer.data.get("id"))
+            serializer = IssueLinkSerializer(issue_link)
+
+            return Response(serializer.data, status=status.HTTP_201_CREATED)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    def partial_update(self, request, slug, project_id, issue_id, pk):
+        issue_link = IssueLink.objects.get(workspace__slug=slug, project_id=project_id, issue_id=issue_id, pk=pk)
+        requested_data = json.dumps(request.data, cls=DjangoJSONEncoder)
+        current_instance = json.dumps(IssueLinkSerializer(issue_link).data, cls=DjangoJSONEncoder)
+
+        serializer = IssueLinkSerializer(issue_link, data=request.data, partial=True)
+        if serializer.is_valid():
+            serializer.save()
+            crawl_work_item_link_title.delay(serializer.data.get("id"), serializer.data.get("url"))
+
+            issue_activity.delay(
+                type="link.activity.updated",
+                requested_data=requested_data,
+                actor_id=str(request.user.id),
+                issue_id=str(issue_id),
+                project_id=str(project_id),
+                current_instance=current_instance,
+                epoch=int(timezone.now().timestamp()),
+                notification=True,
+                origin=base_host(request=request, is_app=True),
+            )
+            issue_link = self.get_queryset().get(id=serializer.data.get("id"))
+            serializer = IssueLinkSerializer(issue_link)
+
+            return Response(serializer.data, status=status.HTTP_200_OK)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    def destroy(self, request, slug, project_id, issue_id, pk):
+        issue_link = IssueLink.objects.get(workspace__slug=slug, project_id=project_id, issue_id=issue_id, pk=pk)
+        current_instance = json.dumps(IssueLinkSerializer(issue_link).data, cls=DjangoJSONEncoder)
+        issue_activity.delay(
+            type="link.activity.deleted",
+            requested_data=json.dumps({"link_id": str(pk)}),
+            actor_id=str(request.user.id),
+            issue_id=str(issue_id),
+            project_id=str(project_id),
+            current_instance=current_instance,
+            epoch=int(timezone.now().timestamp()),
+            notification=True,
+            origin=base_host(request=request, is_app=True),
+        )
+        issue_link.delete()
+        return Response(status=status.HTTP_204_NO_CONTENT)

plane-src/apps/api/plane/app/views/issue/reaction.py

@@ -0,0 +1,85 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+# Python imports
+import json
+
+# Django imports
+from django.utils import timezone
+from django.core.serializers.json import DjangoJSONEncoder
+
+# Third Party imports
+from rest_framework.response import Response
+from rest_framework import status
+
+# Module imports
+from .. import BaseViewSet
+from plane.app.serializers import IssueReactionSerializer
+from plane.app.permissions import allow_permission, ROLE
+from plane.db.models import IssueReaction
+from plane.bgtasks.issue_activities_task import issue_activity
+from plane.utils.host import base_host
+
+
+class IssueReactionViewSet(BaseViewSet):
+    serializer_class = IssueReactionSerializer
+    model = IssueReaction
+
+    def get_queryset(self):
+        return (
+            super()
+            .get_queryset()
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .filter(project_id=self.kwargs.get("project_id"))
+            .filter(issue_id=self.kwargs.get("issue_id"))
+            .filter(
+                project__project_projectmember__member=self.request.user,
+                project__project_projectmember__is_active=True,
+                project__archived_at__isnull=True,
+            )
+            .order_by("-created_at")
+            .distinct()
+        )
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
+    def create(self, request, slug, project_id, issue_id):
+        serializer = IssueReactionSerializer(data=request.data)
+        if serializer.is_valid():
+            serializer.save(issue_id=issue_id, project_id=project_id, actor=request.user)
+            issue_activity.delay(
+                type="issue_reaction.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()),
+                notification=True,
+                origin=base_host(request=request, is_app=True),
+            )
+            return Response(serializer.data, status=status.HTTP_201_CREATED)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
+    def destroy(self, request, slug, project_id, issue_id, reaction_code):
+        issue_reaction = IssueReaction.objects.get(
+            workspace__slug=slug,
+            project_id=project_id,
+            issue_id=issue_id,
+            reaction=reaction_code,
+            actor=request.user,
+        )
+        issue_activity.delay(
+            type="issue_reaction.activity.deleted",
+            requested_data=None,
+            actor_id=str(self.request.user.id),
+            issue_id=str(self.kwargs.get("issue_id", None)),
+            project_id=str(self.kwargs.get("project_id", None)),
+            current_instance=json.dumps({"reaction": str(reaction_code), "identifier": str(issue_reaction.id)}),
+            epoch=int(timezone.now().timestamp()),
+            notification=True,
+            origin=base_host(request=request, is_app=True),
+        )
+        issue_reaction.delete()
+        return Response(status=status.HTTP_204_NO_CONTENT)

plane-src/apps/api/plane/app/views/issue/relation.py

@@ -0,0 +1,284 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+# Python imports
+import json
+
+# Django imports
+from django.utils import timezone
+from django.db.models import Q, OuterRef, F, Func, UUIDField, Value, CharField, Subquery
+from django.core.serializers.json import DjangoJSONEncoder
+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.response import Response
+from rest_framework import status
+
+# Module imports
+from .. import BaseViewSet
+from plane.app.serializers import IssueRelationSerializer, RelatedIssueSerializer
+from plane.app.permissions import ProjectEntityPermission
+from plane.db.models import (
+    Project,
+    IssueRelation,
+    Issue,
+    FileAsset,
+    IssueLink,
+    CycleIssue,
+)
+from plane.bgtasks.issue_activities_task import issue_activity
+from plane.utils.issue_relation_mapper import get_actual_relation
+from plane.utils.host import base_host
+
+
+class IssueRelationViewSet(BaseViewSet):
+    serializer_class = IssueRelationSerializer
+    model = IssueRelation
+    permission_classes = [ProjectEntityPermission]
+
+    def list(self, request, slug, project_id, issue_id):
+        issue_relations = (
+            IssueRelation.objects.filter(Q(issue_id=issue_id) | Q(related_issue=issue_id))
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .select_related("project")
+            .select_related("workspace")
+            .select_related("issue")
+            .order_by("-created_at")
+            .distinct()
+        )
+        # get all blocking issues
+        blocking_issues = issue_relations.filter(relation_type="blocked_by", related_issue_id=issue_id).values_list(
+            "issue_id", flat=True
+        )
+
+        # get all blocked by issues
+        blocked_by_issues = issue_relations.filter(relation_type="blocked_by", issue_id=issue_id).values_list(
+            "related_issue_id", flat=True
+        )
+
+        # get all duplicate issues
+        duplicate_issues = issue_relations.filter(issue_id=issue_id, relation_type="duplicate").values_list(
+            "related_issue_id", flat=True
+        )
+
+        # get all relates to issues
+        duplicate_issues_related = issue_relations.filter(
+            related_issue_id=issue_id, relation_type="duplicate"
+        ).values_list("issue_id", flat=True)
+
+        # get all relates to issues
+        relates_to_issues = issue_relations.filter(issue_id=issue_id, relation_type="relates_to").values_list(
+            "related_issue_id", flat=True
+        )
+
+        # get all relates to issues
+        relates_to_issues_related = issue_relations.filter(
+            related_issue_id=issue_id, relation_type="relates_to"
+        ).values_list("issue_id", flat=True)
+
+        # get all start after issues
+        start_after_issues = issue_relations.filter(
+            relation_type="start_before", related_issue_id=issue_id
+        ).values_list("issue_id", flat=True)
+
+        # get all start_before issues
+        start_before_issues = issue_relations.filter(relation_type="start_before", issue_id=issue_id).values_list(
+            "related_issue_id", flat=True
+        )
+
+        # get all finish after issues
+        finish_after_issues = issue_relations.filter(
+            relation_type="finish_before", related_issue_id=issue_id
+        ).values_list("issue_id", flat=True)
+
+        # get all finish before issues
+        finish_before_issues = issue_relations.filter(relation_type="finish_before", issue_id=issue_id).values_list(
+            "related_issue_id", flat=True
+        )
+
+        queryset = (
+            Issue.issue_objects.filter(workspace__slug=slug)
+            .select_related("workspace", "project", "state", "parent")
+            .prefetch_related("assignees", "labels", "issue_module__module")
+            .annotate(
+                cycle_id=Subquery(
+                    CycleIssue.objects.filter(issue=OuterRef("id"), deleted_at__isnull=True).values("cycle_id")[:1]
+                )
+            )
+            .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")
+            )
+            .annotate(
+                sub_issues_count=Issue.issue_objects.filter(parent=OuterRef("id"))
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
+            .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())),
+                ),
+            )
+        ).distinct()
+
+        # Fields
+        fields = [
+            "id",
+            "name",
+            "state_id",
+            "sort_order",
+            "priority",
+            "sequence_id",
+            "project_id",
+            "label_ids",
+            "assignee_ids",
+            "created_at",
+            "updated_at",
+            "created_by",
+            "updated_by",
+            "relation_type",
+        ]
+
+        response_data = {
+            "blocking": queryset.filter(pk__in=blocking_issues)
+            .annotate(relation_type=Value("blocking", output_field=CharField()))
+            .values(*fields),
+            "blocked_by": queryset.filter(pk__in=blocked_by_issues)
+            .annotate(relation_type=Value("blocked_by", output_field=CharField()))
+            .values(*fields),
+            "duplicate": queryset.filter(pk__in=duplicate_issues)
+            .annotate(relation_type=Value("duplicate", output_field=CharField()))
+            .values(*fields)
+            | queryset.filter(pk__in=duplicate_issues_related)
+            .annotate(relation_type=Value("duplicate", output_field=CharField()))
+            .values(*fields),
+            "relates_to": queryset.filter(pk__in=relates_to_issues)
+            .annotate(relation_type=Value("relates_to", output_field=CharField()))
+            .values(*fields)
+            | queryset.filter(pk__in=relates_to_issues_related)
+            .annotate(relation_type=Value("relates_to", output_field=CharField()))
+            .values(*fields),
+            "start_after": queryset.filter(pk__in=start_after_issues)
+            .annotate(relation_type=Value("start_after", output_field=CharField()))
+            .values(*fields),
+            "start_before": queryset.filter(pk__in=start_before_issues)
+            .annotate(relation_type=Value("start_before", output_field=CharField()))
+            .values(*fields),
+            "finish_after": queryset.filter(pk__in=finish_after_issues)
+            .annotate(relation_type=Value("finish_after", output_field=CharField()))
+            .values(*fields),
+            "finish_before": queryset.filter(pk__in=finish_before_issues)
+            .annotate(relation_type=Value("finish_before", output_field=CharField()))
+            .values(*fields),
+        }
+
+        return Response(response_data, status=status.HTTP_200_OK)
+
+    def create(self, request, slug, project_id, issue_id):
+        relation_type = request.data.get("relation_type", None)
+        if relation_type is None:
+            return Response(
+                {"message": "Issue relation type is required"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        issues = request.data.get("issues", [])
+        project = Project.objects.get(pk=project_id)
+
+        issue_relation = IssueRelation.objects.bulk_create(
+            [
+                IssueRelation(
+                    issue_id=(issue if relation_type in ["blocking", "start_after", "finish_after"] else issue_id),
+                    related_issue_id=(
+                        issue_id if relation_type in ["blocking", "start_after", "finish_after"] else issue
+                    ),
+                    relation_type=(get_actual_relation(relation_type)),
+                    project_id=project_id,
+                    workspace_id=project.workspace_id,
+                    created_by=request.user,
+                    updated_by=request.user,
+                )
+                for issue in issues
+            ],
+            batch_size=10,
+            ignore_conflicts=True,
+        )
+
+        issue_activity.delay(
+            type="issue_relation.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()),
+            notification=True,
+            origin=base_host(request=request, is_app=True),
+        )
+
+        if relation_type in ["blocking", "start_after", "finish_after"]:
+            return Response(
+                RelatedIssueSerializer(issue_relation, many=True).data,
+                status=status.HTTP_201_CREATED,
+            )
+        else:
+            return Response(
+                IssueRelationSerializer(issue_relation, many=True).data,
+                status=status.HTTP_201_CREATED,
+            )
+
+    def remove_relation(self, request, slug, project_id, issue_id):
+        related_issue = request.data.get("related_issue", None)
+
+        issue_relations = IssueRelation.objects.filter(
+            workspace__slug=slug,
+        ).filter(
+            Q(issue_id=related_issue, related_issue_id=issue_id) | Q(issue_id=issue_id, related_issue_id=related_issue)
+        )
+        issue_relations = issue_relations.first()
+        current_instance = json.dumps(IssueRelationSerializer(issue_relations).data, cls=DjangoJSONEncoder)
+        issue_relations.delete()
+        issue_activity.delay(
+            type="issue_relation.activity.deleted",
+            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=True,
+            origin=base_host(request=request, is_app=True),
+        )
+        return Response(status=status.HTTP_204_NO_CONTENT)

plane-src/apps/api/plane/app/views/issue/sub_issue.py

@@ -0,0 +1,217 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+# Python imports
+import json
+
+# Django imports
+from django.utils import timezone
+from django.db.models import OuterRef, Func, F, Q, Value, UUIDField, Subquery
+from django.utils.decorators import method_decorator
+from django.views.decorators.gzip import gzip_page
+from django.contrib.postgres.aggregates import ArrayAgg
+from django.contrib.postgres.fields import ArrayField
+from django.db.models.functions import Coalesce
+
+# Third Party imports
+from rest_framework.response import Response
+from rest_framework import status
+
+# Module imports
+from .. import BaseAPIView
+from plane.app.serializers import IssueSerializer
+from plane.app.permissions import ProjectEntityPermission
+from plane.db.models import Issue, IssueLink, FileAsset, CycleIssue
+from plane.bgtasks.issue_activities_task import issue_activity
+from plane.utils.timezone_converter import user_timezone_converter
+from collections import defaultdict
+from plane.utils.host import base_host
+from plane.utils.order_queryset import order_issue_queryset
+
+
+class SubIssuesEndpoint(BaseAPIView):
+    permission_classes = [ProjectEntityPermission]
+
+    @method_decorator(gzip_page)
+    def get(self, request, slug, project_id, issue_id):
+        sub_issues = (
+            Issue.issue_objects.filter(parent_id=issue_id, workspace__slug=slug)
+            .select_related("workspace", "project", "state", "parent")
+            .prefetch_related("assignees", "labels", "issue_module__module")
+            .annotate(
+                cycle_id=Subquery(
+                    CycleIssue.objects.filter(issue=OuterRef("id"), deleted_at__isnull=True).values("cycle_id")[:1]
+                )
+            )
+            .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")
+            )
+            .annotate(
+                sub_issues_count=Issue.issue_objects.filter(parent=OuterRef("id"))
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
+            .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())),
+                ),
+                module_ids=Coalesce(
+                    ArrayAgg(
+                        "issue_module__module_id",
+                        distinct=True,
+                        filter=Q(
+                            ~Q(issue_module__module_id__isnull=True)
+                            & Q(issue_module__module__archived_at__isnull=True)
+                            & Q(issue_module__deleted_at__isnull=True)
+                        ),
+                    ),
+                    Value([], output_field=ArrayField(UUIDField())),
+                ),
+            )
+            .annotate(state_group=F("state__group"))
+            .order_by("-created_at")
+        )
+
+        # Ordering
+        order_by_param = request.GET.get("order_by", "-created_at")
+        group_by = request.GET.get("group_by", False)
+
+        if order_by_param:
+            sub_issues, order_by_param = order_issue_queryset(sub_issues, order_by_param)
+
+        # create's a dict with state group name with their respective issue id's
+        result = defaultdict(list)
+        for sub_issue in sub_issues:
+            result[sub_issue.state_group].append(str(sub_issue.id))
+
+        sub_issues = sub_issues.values(
+            "id",
+            "name",
+            "state_id",
+            "sort_order",
+            "completed_at",
+            "estimate_point",
+            "priority",
+            "start_date",
+            "target_date",
+            "sequence_id",
+            "project_id",
+            "parent_id",
+            "cycle_id",
+            "module_ids",
+            "label_ids",
+            "assignee_ids",
+            "sub_issues_count",
+            "created_at",
+            "updated_at",
+            "created_by",
+            "updated_by",
+            "attachment_count",
+            "link_count",
+            "is_draft",
+            "archived_at",
+        )
+        datetime_fields = ["created_at", "updated_at"]
+        sub_issues = user_timezone_converter(sub_issues, datetime_fields, request.user.user_timezone)
+        # Grouping
+        if group_by:
+            result_dict = defaultdict(list)
+
+            for issue in sub_issues:
+                if group_by == "assignees__ids":
+                    if issue["assignee_ids"]:
+                        assignee_ids = issue["assignee_ids"]
+                        for assignee_id in assignee_ids:
+                            result_dict[str(assignee_id)].append(issue)
+                    elif issue["assignee_ids"] == []:
+                        result_dict["None"].append(issue)
+
+                elif group_by:
+                    result_dict[str(issue[group_by])].append(issue)
+
+            return Response(
+                {"sub_issues": result_dict, "state_distribution": result},
+                status=status.HTTP_200_OK,
+            )
+        return Response(
+            {"sub_issues": sub_issues, "state_distribution": result},
+            status=status.HTTP_200_OK,
+        )
+
+    # Assign multiple sub issues
+    def post(self, request, slug, project_id, issue_id):
+        parent_issue = Issue.issue_objects.get(pk=issue_id)
+        sub_issue_ids = request.data.get("sub_issue_ids", [])
+
+        if not len(sub_issue_ids):
+            return Response(
+                {"error": "Sub Issue IDs are required"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        sub_issues = Issue.issue_objects.filter(id__in=sub_issue_ids)
+
+        for sub_issue in sub_issues:
+            sub_issue.parent = parent_issue
+
+        _ = Issue.objects.bulk_update(sub_issues, ["parent"], batch_size=10)
+
+        updated_sub_issues = Issue.issue_objects.filter(id__in=sub_issue_ids).annotate(state_group=F("state__group"))
+
+        # Track the issue
+        _ = [
+            issue_activity.delay(
+                type="issue.activity.updated",
+                requested_data=json.dumps({"parent": str(issue_id)}),
+                actor_id=str(request.user.id),
+                issue_id=str(sub_issue_id),
+                project_id=str(project_id),
+                current_instance=json.dumps({"parent": str(sub_issue_id)}),
+                epoch=int(timezone.now().timestamp()),
+                notification=True,
+                origin=base_host(request=request, is_app=True),
+            )
+            for sub_issue_id in sub_issue_ids
+        ]
+
+        # create's a dict with state group name with their respective issue id's
+        result = defaultdict(list)
+        for sub_issue in updated_sub_issues:
+            result[sub_issue.state_group].append(str(sub_issue.id))
+
+        serializer = IssueSerializer(updated_sub_issues, many=True)
+        return Response(
+            {"sub_issues": serializer.data, "state_distribution": result},
+            status=status.HTTP_200_OK,
+        )

plane-src/apps/api/plane/app/views/issue/subscriber.py

@@ -0,0 +1,104 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+# Third Party imports
+from rest_framework.response import Response
+from rest_framework import status
+
+# Module imports
+from .. import BaseViewSet
+from plane.app.serializers import IssueSubscriberSerializer, ProjectMemberLiteSerializer
+from plane.app.permissions import ProjectEntityPermission, ProjectLitePermission
+from plane.db.models import IssueSubscriber, ProjectMember
+
+
+class IssueSubscriberViewSet(BaseViewSet):
+    serializer_class = IssueSubscriberSerializer
+    model = IssueSubscriber
+
+    permission_classes = [ProjectEntityPermission]
+
+    def get_permissions(self):
+        if self.action in ["subscribe", "unsubscribe", "subscription_status"]:
+            self.permission_classes = [ProjectLitePermission]
+        else:
+            self.permission_classes = [ProjectEntityPermission]
+
+        return super(IssueSubscriberViewSet, self).get_permissions()
+
+    def perform_create(self, serializer):
+        serializer.save(
+            project_id=self.kwargs.get("project_id"),
+            issue_id=self.kwargs.get("issue_id"),
+        )
+
+    def get_queryset(self):
+        return (
+            super()
+            .get_queryset()
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .filter(project_id=self.kwargs.get("project_id"))
+            .filter(issue_id=self.kwargs.get("issue_id"))
+            .filter(
+                project__project_projectmember__member=self.request.user,
+                project__project_projectmember__is_active=True,
+                project__archived_at__isnull=True,
+            )
+            .order_by("-created_at")
+            .distinct()
+        )
+
+    def list(self, request, slug, project_id, issue_id):
+        members = ProjectMember.objects.filter(
+            workspace__slug=slug, project_id=project_id, is_active=True
+        ).select_related("member")
+        serializer = ProjectMemberLiteSerializer(members, many=True)
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+    def destroy(self, request, slug, project_id, issue_id, subscriber_id):
+        issue_subscriber = IssueSubscriber.objects.get(
+            project=project_id,
+            subscriber=subscriber_id,
+            workspace__slug=slug,
+            issue=issue_id,
+        )
+        issue_subscriber.delete()
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+    def subscribe(self, request, slug, project_id, issue_id):
+        if IssueSubscriber.objects.filter(
+            issue_id=issue_id,
+            subscriber=request.user,
+            workspace__slug=slug,
+            project=project_id,
+        ).exists():
+            return Response(
+                {"message": "User already subscribed to the issue."},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        subscriber = IssueSubscriber.objects.create(
+            issue_id=issue_id, subscriber_id=request.user.id, project_id=project_id
+        )
+        serializer = IssueSubscriberSerializer(subscriber)
+        return Response(serializer.data, status=status.HTTP_201_CREATED)
+
+    def unsubscribe(self, request, slug, project_id, issue_id):
+        issue_subscriber = IssueSubscriber.objects.get(
+            project=project_id,
+            subscriber=request.user,
+            workspace__slug=slug,
+            issue=issue_id,
+        )
+        issue_subscriber.delete()
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+    def subscription_status(self, request, slug, project_id, issue_id):
+        issue_subscriber = IssueSubscriber.objects.filter(
+            issue=issue_id,
+            subscriber=request.user,
+            workspace__slug=slug,
+            project=project_id,
+        ).exists()
+        return Response({"subscribed": issue_subscriber}, status=status.HTTP_200_OK)

plane-src/apps/api/plane/app/views/issue/version.py

@@ -0,0 +1,144 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+# Third party imports
+from rest_framework import status
+from rest_framework.response import Response
+
+# Module imports
+from plane.db.models import (
+    IssueVersion,
+    IssueDescriptionVersion,
+    Project,
+    ProjectMember,
+    Issue,
+)
+from ..base import BaseAPIView
+from plane.app.serializers import (
+    IssueVersionDetailSerializer,
+    IssueDescriptionVersionDetailSerializer,
+)
+from plane.app.permissions import allow_permission, ROLE
+from plane.utils.global_paginator import paginate
+from plane.utils.timezone_converter import user_timezone_converter
+
+
+class IssueVersionEndpoint(BaseAPIView):
+    def process_paginated_result(self, fields, results, timezone):
+        paginated_data = results.values(*fields)
+
+        datetime_fields = ["created_at", "updated_at"]
+        paginated_data = user_timezone_converter(paginated_data, datetime_fields, timezone)
+
+        return paginated_data
+
+    @allow_permission(allowed_roles=[ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
+    def get(self, request, slug, project_id, issue_id, pk=None):
+        if pk:
+            issue_version = IssueVersion.objects.get(
+                workspace__slug=slug, project_id=project_id, issue_id=issue_id, pk=pk
+            )
+
+            serializer = IssueVersionDetailSerializer(issue_version)
+            return Response(serializer.data, status=status.HTTP_200_OK)
+
+        cursor = request.GET.get("cursor", None)
+
+        required_fields = [
+            "id",
+            "workspace",
+            "project",
+            "issue",
+            "last_saved_at",
+            "owned_by",
+            "created_at",
+            "updated_at",
+            "created_by",
+            "updated_by",
+        ]
+
+        issue_versions_queryset = IssueVersion.objects.filter(
+            workspace__slug=slug, project_id=project_id, issue_id=issue_id
+        )
+
+        paginated_data = paginate(
+            base_queryset=issue_versions_queryset,
+            queryset=issue_versions_queryset,
+            cursor=cursor,
+            on_result=lambda results: self.process_paginated_result(
+                required_fields, results, request.user.user_timezone
+            ),
+        )
+
+        return Response(paginated_data, status=status.HTTP_200_OK)
+
+
+class WorkItemDescriptionVersionEndpoint(BaseAPIView):
+    def process_paginated_result(self, fields, results, timezone):
+        paginated_data = results.values(*fields)
+
+        datetime_fields = ["created_at", "updated_at"]
+        paginated_data = user_timezone_converter(paginated_data, datetime_fields, timezone)
+
+        return paginated_data
+
+    @allow_permission(allowed_roles=[ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
+    def get(self, request, slug, project_id, work_item_id, pk=None):
+        project = Project.objects.get(pk=project_id)
+        issue = Issue.objects.get(workspace__slug=slug, project_id=project_id, pk=work_item_id)
+
+        if (
+            ProjectMember.objects.filter(
+                workspace__slug=slug,
+                project_id=project_id,
+                member=request.user,
+                role=ROLE.GUEST.value,
+                is_active=True,
+            ).exists()
+            and not project.guest_view_all_features
+            and not issue.created_by == request.user
+        ):
+            return Response(
+                {"error": "You are not allowed to view this issue"},
+                status=status.HTTP_403_FORBIDDEN,
+            )
+
+        if pk:
+            issue_description_version = IssueDescriptionVersion.objects.get(
+                workspace__slug=slug,
+                project_id=project_id,
+                issue_id=work_item_id,
+                pk=pk,
+            )
+
+            serializer = IssueDescriptionVersionDetailSerializer(issue_description_version)
+            return Response(serializer.data, status=status.HTTP_200_OK)
+
+        cursor = request.GET.get("cursor", None)
+
+        required_fields = [
+            "id",
+            "workspace",
+            "project",
+            "issue",
+            "last_saved_at",
+            "owned_by",
+            "created_at",
+            "updated_at",
+            "created_by",
+            "updated_by",
+        ]
+
+        issue_description_versions_queryset = IssueDescriptionVersion.objects.filter(
+            workspace__slug=slug, project_id=project_id, issue_id=work_item_id
+        ).order_by("-created_at")
+        paginated_data = paginate(
+            base_queryset=issue_description_versions_queryset,
+            queryset=issue_description_versions_queryset,
+            cursor=cursor,
+            on_result=lambda results: self.process_paginated_result(
+                required_fields, results, request.user.user_timezone
+            ),
+        )
+        return Response(paginated_data, status=status.HTTP_200_OK)

plane-src/apps/api/plane/app/views/module/archive.py

@@ -0,0 +1,565 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+from django.contrib.postgres.aggregates import ArrayAgg
+from django.contrib.postgres.fields import ArrayField
+from django.db.models import (
+    Count,
+    Exists,
+    F,
+    Func,
+    IntegerField,
+    OuterRef,
+    Prefetch,
+    Q,
+    Subquery,
+    UUIDField,
+    Value,
+    Sum,
+    FloatField,
+    Case,
+    When,
+)
+from django.db.models.functions import Coalesce, Cast, Concat
+from django.utils import timezone
+from django.db import models
+
+# Third party imports
+from rest_framework import status
+from rest_framework.response import Response
+from plane.app.permissions import ProjectEntityPermission
+from plane.app.serializers import ModuleDetailSerializer
+from plane.db.models import Issue, Module, ModuleLink, UserFavorite, Project
+from plane.utils.analytics_plot import burndown_plot
+from plane.utils.timezone_converter import user_timezone_converter
+
+
+# Module imports
+from .. import BaseAPIView
+
+
+class ModuleArchiveUnarchiveEndpoint(BaseAPIView):
+    permission_classes = [ProjectEntityPermission]
+
+    def get_queryset(self):
+        favorite_subquery = UserFavorite.objects.filter(
+            user=self.request.user,
+            entity_type="module",
+            entity_identifier=OuterRef("pk"),
+            project_id=self.kwargs.get("project_id"),
+            workspace__slug=self.kwargs.get("slug"),
+        )
+        cancelled_issues = (
+            Issue.issue_objects.filter(
+                state__group="cancelled",
+                issue_module__module_id=OuterRef("pk"),
+                issue_module__deleted_at__isnull=True,
+            )
+            .values("issue_module__module_id")
+            .annotate(cnt=Count("pk"))
+            .values("cnt")
+        )
+        completed_issues = (
+            Issue.issue_objects.filter(
+                state__group="completed",
+                issue_module__module_id=OuterRef("pk"),
+                issue_module__deleted_at__isnull=True,
+            )
+            .values("issue_module__module_id")
+            .annotate(cnt=Count("pk"))
+            .values("cnt")
+        )
+        started_issues = (
+            Issue.issue_objects.filter(
+                state__group="started",
+                issue_module__module_id=OuterRef("pk"),
+                issue_module__deleted_at__isnull=True,
+            )
+            .values("issue_module__module_id")
+            .annotate(cnt=Count("pk"))
+            .values("cnt")
+        )
+        unstarted_issues = (
+            Issue.issue_objects.filter(
+                state__group="unstarted",
+                issue_module__module_id=OuterRef("pk"),
+                issue_module__deleted_at__isnull=True,
+            )
+            .values("issue_module__module_id")
+            .annotate(cnt=Count("pk"))
+            .values("cnt")
+        )
+        backlog_issues = (
+            Issue.issue_objects.filter(
+                state__group="backlog",
+                issue_module__module_id=OuterRef("pk"),
+                issue_module__deleted_at__isnull=True,
+            )
+            .values("issue_module__module_id")
+            .annotate(cnt=Count("pk"))
+            .values("cnt")
+        )
+        total_issues = (
+            Issue.issue_objects.filter(
+                issue_module__module_id=OuterRef("pk"),
+                issue_module__deleted_at__isnull=True,
+            )
+            .values("issue_module__module_id")
+            .annotate(cnt=Count("pk"))
+            .values("cnt")
+        )
+        completed_estimate_point = (
+            Issue.issue_objects.filter(
+                estimate_point__estimate__type="points",
+                state__group="completed",
+                issue_module__module_id=OuterRef("pk"),
+                issue_module__deleted_at__isnull=True,
+            )
+            .values("issue_module__module_id")
+            .annotate(completed_estimate_points=Sum(Cast("estimate_point__value", FloatField())))
+            .values("completed_estimate_points")[:1]
+        )
+
+        total_estimate_point = (
+            Issue.issue_objects.filter(
+                estimate_point__estimate__type="points",
+                issue_module__module_id=OuterRef("pk"),
+                issue_module__deleted_at__isnull=True,
+            )
+            .values("issue_module__module_id")
+            .annotate(total_estimate_points=Sum(Cast("estimate_point__value", FloatField())))
+            .values("total_estimate_points")[:1]
+        )
+        backlog_estimate_point = (
+            Issue.issue_objects.filter(
+                estimate_point__estimate__type="points",
+                state__group="backlog",
+                issue_module__module_id=OuterRef("pk"),
+                issue_module__deleted_at__isnull=True,
+            )
+            .values("issue_module__module_id")
+            .annotate(backlog_estimate_point=Sum(Cast("estimate_point__value", FloatField())))
+            .values("backlog_estimate_point")[:1]
+        )
+        unstarted_estimate_point = (
+            Issue.issue_objects.filter(
+                estimate_point__estimate__type="points",
+                state__group="unstarted",
+                issue_module__module_id=OuterRef("pk"),
+                issue_module__deleted_at__isnull=True,
+            )
+            .values("issue_module__module_id")
+            .annotate(unstarted_estimate_point=Sum(Cast("estimate_point__value", FloatField())))
+            .values("unstarted_estimate_point")[:1]
+        )
+        started_estimate_point = (
+            Issue.issue_objects.filter(
+                estimate_point__estimate__type="points",
+                state__group="started",
+                issue_module__module_id=OuterRef("pk"),
+                issue_module__deleted_at__isnull=True,
+            )
+            .values("issue_module__module_id")
+            .annotate(started_estimate_point=Sum(Cast("estimate_point__value", FloatField())))
+            .values("started_estimate_point")[:1]
+        )
+        cancelled_estimate_point = (
+            Issue.issue_objects.filter(
+                estimate_point__estimate__type="points",
+                state__group="cancelled",
+                issue_module__module_id=OuterRef("pk"),
+                issue_module__deleted_at__isnull=True,
+            )
+            .values("issue_module__module_id")
+            .annotate(cancelled_estimate_point=Sum(Cast("estimate_point__value", FloatField())))
+            .values("cancelled_estimate_point")[:1]
+        )
+        return (
+            Module.objects.filter(workspace__slug=self.kwargs.get("slug"))
+            .filter(project_id=self.kwargs.get("project_id"))
+            .filter(archived_at__isnull=False)
+            .annotate(is_favorite=Exists(favorite_subquery))
+            .select_related("workspace", "project", "lead")
+            .prefetch_related("members")
+            .prefetch_related(
+                Prefetch(
+                    "link_module",
+                    queryset=ModuleLink.objects.select_related("module", "created_by"),
+                )
+            )
+            .annotate(
+                completed_issues=Coalesce(
+                    Subquery(completed_issues[:1]),
+                    Value(0, output_field=IntegerField()),
+                )
+            )
+            .annotate(
+                cancelled_issues=Coalesce(
+                    Subquery(cancelled_issues[:1]),
+                    Value(0, output_field=IntegerField()),
+                )
+            )
+            .annotate(started_issues=Coalesce(Subquery(started_issues[:1]), Value(0, output_field=IntegerField())))
+            .annotate(
+                unstarted_issues=Coalesce(
+                    Subquery(unstarted_issues[:1]),
+                    Value(0, output_field=IntegerField()),
+                )
+            )
+            .annotate(backlog_issues=Coalesce(Subquery(backlog_issues[:1]), Value(0, output_field=IntegerField())))
+            .annotate(total_issues=Coalesce(Subquery(total_issues[:1]), Value(0, output_field=IntegerField())))
+            .annotate(
+                backlog_estimate_points=Coalesce(
+                    Subquery(backlog_estimate_point),
+                    Value(0, output_field=FloatField()),
+                )
+            )
+            .annotate(
+                unstarted_estimate_points=Coalesce(
+                    Subquery(unstarted_estimate_point),
+                    Value(0, output_field=FloatField()),
+                )
+            )
+            .annotate(
+                started_estimate_points=Coalesce(
+                    Subquery(started_estimate_point),
+                    Value(0, output_field=FloatField()),
+                )
+            )
+            .annotate(
+                cancelled_estimate_points=Coalesce(
+                    Subquery(cancelled_estimate_point),
+                    Value(0, output_field=FloatField()),
+                )
+            )
+            .annotate(
+                completed_estimate_points=Coalesce(
+                    Subquery(completed_estimate_point),
+                    Value(0, output_field=FloatField()),
+                )
+            )
+            .annotate(
+                total_estimate_points=Coalesce(Subquery(total_estimate_point), Value(0, output_field=FloatField()))
+            )
+            .annotate(
+                member_ids=Coalesce(
+                    ArrayAgg(
+                        "members__id",
+                        distinct=True,
+                        filter=~Q(members__id__isnull=True),
+                    ),
+                    Value([], output_field=ArrayField(UUIDField())),
+                )
+            )
+            .order_by("-is_favorite", "-created_at")
+        )
+
+    def get(self, request, slug, project_id, pk=None):
+        if pk is None:
+            queryset = self.get_queryset()
+            modules = queryset.values(  # Required fields
+                "id",
+                "workspace_id",
+                "project_id",
+                # Model fields
+                "name",
+                "description",
+                "description_text",
+                "description_html",
+                "start_date",
+                "target_date",
+                "status",
+                "lead_id",
+                "member_ids",
+                "view_props",
+                "sort_order",
+                "external_source",
+                "external_id",
+                # computed fields
+                "total_issues",
+                "is_favorite",
+                "cancelled_issues",
+                "completed_issues",
+                "started_issues",
+                "unstarted_issues",
+                "backlog_issues",
+                "created_at",
+                "updated_at",
+                "archived_at",
+            )
+            datetime_fields = ["created_at", "updated_at"]
+            modules = user_timezone_converter(modules, datetime_fields, request.user.user_timezone)
+            return Response(modules, status=status.HTTP_200_OK)
+        else:
+            queryset = (
+                self.get_queryset()
+                .filter(pk=pk)
+                .annotate(
+                    sub_issues=Issue.issue_objects.filter(
+                        project_id=self.kwargs.get("project_id"),
+                        parent__isnull=False,
+                        issue_module__module_id=pk,
+                        issue_module__deleted_at__isnull=True,
+                    )
+                    .order_by()
+                    .annotate(count=Func(F("id"), function="Count"))
+                    .values("count")
+                )
+            )
+
+            estimate_type = Project.objects.filter(
+                workspace__slug=slug,
+                pk=project_id,
+                estimate__isnull=False,
+                estimate__type="points",
+            ).exists()
+
+            data = ModuleDetailSerializer(queryset.first()).data
+            modules = queryset.first()
+
+            data["estimate_distribution"] = {}
+
+            if estimate_type:
+                assignee_distribution = (
+                    Issue.issue_objects.filter(
+                        issue_module__module_id=pk,
+                        issue_module__deleted_at__isnull=True,
+                        workspace__slug=slug,
+                        project_id=project_id,
+                    )
+                    .annotate(first_name=F("assignees__first_name"))
+                    .annotate(last_name=F("assignees__last_name"))
+                    .annotate(assignee_id=F("assignees__id"))
+                    .annotate(display_name=F("assignees__display_name"))
+                    .annotate(
+                        avatar_url=Case(
+                            # If `avatar_asset` exists, use it to generate the asset URL
+                            When(
+                                assignees__avatar_asset__isnull=False,
+                                then=Concat(
+                                    Value("/api/assets/v2/static/"),
+                                    "assignees__avatar_asset",  # Assuming avatar_asset has an id or relevant field
+                                    Value("/"),
+                                ),
+                            ),
+                            # If `avatar_asset` is None, fall back to using `avatar` field directly
+                            When(
+                                assignees__avatar_asset__isnull=True,
+                                then="assignees__avatar",
+                            ),
+                            default=Value(None),
+                            output_field=models.CharField(),
+                        )
+                    )
+                    .values(
+                        "first_name",
+                        "last_name",
+                        "assignee_id",
+                        "avatar_url",
+                        "display_name",
+                    )
+                    .annotate(total_estimates=Sum(Cast("estimate_point__value", FloatField())))
+                    .annotate(
+                        completed_estimates=Sum(
+                            Cast("estimate_point__value", FloatField()),
+                            filter=Q(
+                                completed_at__isnull=False,
+                                archived_at__isnull=True,
+                                is_draft=False,
+                            ),
+                        )
+                    )
+                    .annotate(
+                        pending_estimates=Sum(
+                            Cast("estimate_point__value", FloatField()),
+                            filter=Q(
+                                completed_at__isnull=True,
+                                archived_at__isnull=True,
+                                is_draft=False,
+                            ),
+                        )
+                    )
+                    .order_by("first_name", "last_name")
+                )
+
+                label_distribution = (
+                    Issue.issue_objects.filter(
+                        issue_module__module_id=pk,
+                        workspace__slug=slug,
+                        project_id=project_id,
+                    )
+                    .annotate(label_name=F("labels__name"))
+                    .annotate(color=F("labels__color"))
+                    .annotate(label_id=F("labels__id"))
+                    .values("label_name", "color", "label_id")
+                    .annotate(total_estimates=Sum(Cast("estimate_point__value", FloatField())))
+                    .annotate(
+                        completed_estimates=Sum(
+                            Cast("estimate_point__value", FloatField()),
+                            filter=Q(
+                                completed_at__isnull=False,
+                                archived_at__isnull=True,
+                                is_draft=False,
+                            ),
+                        )
+                    )
+                    .annotate(
+                        pending_estimates=Sum(
+                            Cast("estimate_point__value", FloatField()),
+                            filter=Q(
+                                completed_at__isnull=True,
+                                archived_at__isnull=True,
+                                is_draft=False,
+                            ),
+                        )
+                    )
+                    .order_by("label_name")
+                )
+                data["estimate_distribution"]["assignees"] = assignee_distribution
+                data["estimate_distribution"]["labels"] = label_distribution
+
+                if modules and modules.start_date and modules.target_date:
+                    data["estimate_distribution"]["completion_chart"] = burndown_plot(
+                        queryset=modules,
+                        slug=slug,
+                        project_id=project_id,
+                        plot_type="points",
+                        module_id=pk,
+                    )
+
+            assignee_distribution = (
+                Issue.issue_objects.filter(
+                    issue_module__module_id=pk,
+                    issue_module__deleted_at__isnull=True,
+                    workspace__slug=slug,
+                    project_id=project_id,
+                )
+                .annotate(first_name=F("assignees__first_name"))
+                .annotate(last_name=F("assignees__last_name"))
+                .annotate(assignee_id=F("assignees__id"))
+                .annotate(display_name=F("assignees__display_name"))
+                .annotate(
+                    avatar_url=Case(
+                        # If `avatar_asset` exists, use it to generate the asset URL
+                        When(
+                            assignees__avatar_asset__isnull=False,
+                            then=Concat(
+                                Value("/api/assets/v2/static/"),
+                                "assignees__avatar_asset",  # Assuming avatar_asset has an id or relevant field
+                                Value("/"),
+                            ),
+                        ),
+                        # If `avatar_asset` is None, fall back to using `avatar` field directly
+                        When(
+                            assignees__avatar_asset__isnull=True,
+                            then="assignees__avatar",
+                        ),
+                        default=Value(None),
+                        output_field=models.CharField(),
+                    )
+                )
+                .values(
+                    "first_name",
+                    "last_name",
+                    "assignee_id",
+                    "avatar_url",
+                    "display_name",
+                )
+                .annotate(total_issues=Count("id", filter=Q(archived_at__isnull=True, is_draft=False)))
+                .annotate(
+                    completed_issues=Count(
+                        "id",
+                        filter=Q(
+                            completed_at__isnull=False,
+                            archived_at__isnull=True,
+                            is_draft=False,
+                        ),
+                    )
+                )
+                .annotate(
+                    pending_issues=Count(
+                        "id",
+                        filter=Q(
+                            completed_at__isnull=True,
+                            archived_at__isnull=True,
+                            is_draft=False,
+                        ),
+                    )
+                )
+                .order_by("first_name", "last_name")
+            )
+
+            label_distribution = (
+                Issue.issue_objects.filter(
+                    issue_module__module_id=pk,
+                    issue_module__deleted_at__isnull=True,
+                    workspace__slug=slug,
+                    project_id=project_id,
+                )
+                .annotate(label_name=F("labels__name"))
+                .annotate(color=F("labels__color"))
+                .annotate(label_id=F("labels__id"))
+                .values("label_name", "color", "label_id")
+                .annotate(total_issues=Count("id", filter=Q(archived_at__isnull=True, is_draft=False)))
+                .annotate(
+                    completed_issues=Count(
+                        "id",
+                        filter=Q(
+                            completed_at__isnull=False,
+                            archived_at__isnull=True,
+                            is_draft=False,
+                        ),
+                    )
+                )
+                .annotate(
+                    pending_issues=Count(
+                        "id",
+                        filter=Q(
+                            completed_at__isnull=True,
+                            archived_at__isnull=True,
+                            is_draft=False,
+                        ),
+                    )
+                )
+                .order_by("label_name")
+            )
+
+            data["distribution"] = {
+                "assignees": assignee_distribution,
+                "labels": label_distribution,
+                "completion_chart": {},
+            }
+            if modules and modules.start_date and modules.target_date:
+                data["distribution"]["completion_chart"] = burndown_plot(
+                    queryset=modules,
+                    slug=slug,
+                    project_id=project_id,
+                    plot_type="issues",
+                    module_id=pk,
+                )
+
+            return Response(data, status=status.HTTP_200_OK)
+
+    def post(self, request, slug, project_id, module_id):
+        module = Module.objects.get(pk=module_id, 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=module_id,
+            project_id=project_id,
+            workspace__slug=slug,
+        ).delete()
+        return Response({"archived_at": str(module.archived_at)}, status=status.HTTP_200_OK)
+
+    def delete(self, request, slug, project_id, module_id):
+        module = Module.objects.get(pk=module_id, project_id=project_id, workspace__slug=slug)
+        module.archived_at = None
+        module.save()
+        return Response(status=status.HTTP_204_NO_CONTENT)

plane-src/apps/api/plane/app/views/module/base.py

@@ -0,0 +1,855 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+# Python imports
+import json
+
+# Django Imports
+from django.contrib.postgres.aggregates import ArrayAgg
+from django.contrib.postgres.fields import ArrayField
+from django.db.models import (
+    Count,
+    Exists,
+    F,
+    Func,
+    IntegerField,
+    OuterRef,
+    Prefetch,
+    Q,
+    Subquery,
+    UUIDField,
+    Value,
+    Sum,
+    FloatField,
+    Case,
+    When,
+)
+from django.db import models
+from django.db.models.functions import Coalesce, Cast, Concat
+from django.core.serializers.json import DjangoJSONEncoder
+from django.utils import timezone
+
+# Third party imports
+from rest_framework import status
+from rest_framework.response import Response
+
+# Module imports
+from plane.app.permissions import (
+    ProjectEntityPermission,
+    ProjectLitePermission,
+    allow_permission,
+    ROLE,
+)
+
+from plane.app.serializers import (
+    ModuleDetailSerializer,
+    ModuleLinkSerializer,
+    ModuleSerializer,
+    ModuleUserPropertiesSerializer,
+    ModuleWriteSerializer,
+)
+from plane.bgtasks.issue_activities_task import issue_activity
+from plane.db.models import (
+    Issue,
+    Module,
+    UserFavorite,
+    ModuleIssue,
+    ModuleLink,
+    ModuleUserProperties,
+    Project,
+    UserRecentVisit,
+)
+from plane.utils.analytics_plot import burndown_plot
+from plane.utils.timezone_converter import user_timezone_converter
+from plane.bgtasks.webhook_task import model_activity
+from .. import BaseAPIView, BaseViewSet
+from plane.bgtasks.recent_visited_task import recent_visited_task
+from plane.utils.host import base_host
+
+
+class ModuleViewSet(BaseViewSet):
+    model = Module
+    webhook_event = "module"
+
+    def get_serializer_class(self):
+        return ModuleWriteSerializer if self.action in ["create", "update", "partial_update"] else ModuleSerializer
+
+    def get_queryset(self):
+        favorite_subquery = UserFavorite.objects.filter(
+            user=self.request.user,
+            entity_type="module",
+            entity_identifier=OuterRef("pk"),
+            project_id=self.kwargs.get("project_id"),
+            workspace__slug=self.kwargs.get("slug"),
+        )
+        cancelled_issues = (
+            Issue.issue_objects.filter(
+                state__group="cancelled",
+                issue_module__module_id=OuterRef("pk"),
+                issue_module__deleted_at__isnull=True,
+            )
+            .values("issue_module__module_id")
+            .annotate(cnt=Count("pk"))
+            .values("cnt")
+        )
+        completed_issues = (
+            Issue.issue_objects.filter(
+                state__group="completed",
+                issue_module__module_id=OuterRef("pk"),
+                issue_module__deleted_at__isnull=True,
+            )
+            .values("issue_module__module_id")
+            .annotate(cnt=Count("pk"))
+            .values("cnt")
+        )
+        started_issues = (
+            Issue.issue_objects.filter(
+                state__group="started",
+                issue_module__module_id=OuterRef("pk"),
+                issue_module__deleted_at__isnull=True,
+            )
+            .values("issue_module__module_id")
+            .annotate(cnt=Count("pk"))
+            .values("cnt")
+        )
+        unstarted_issues = (
+            Issue.issue_objects.filter(
+                state__group="unstarted",
+                issue_module__module_id=OuterRef("pk"),
+                issue_module__deleted_at__isnull=True,
+            )
+            .values("issue_module__module_id")
+            .annotate(cnt=Count("pk"))
+            .values("cnt")
+        )
+        backlog_issues = (
+            Issue.issue_objects.filter(
+                state__group="backlog",
+                issue_module__module_id=OuterRef("pk"),
+                issue_module__deleted_at__isnull=True,
+            )
+            .values("issue_module__module_id")
+            .annotate(cnt=Count("pk"))
+            .values("cnt")
+        )
+        total_issues = (
+            Issue.issue_objects.filter(
+                issue_module__module_id=OuterRef("pk"),
+                issue_module__deleted_at__isnull=True,
+            )
+            .values("issue_module__module_id")
+            .annotate(cnt=Count("pk"))
+            .values("cnt")
+        )
+        completed_estimate_point = (
+            Issue.issue_objects.filter(
+                estimate_point__estimate__type="points",
+                state__group="completed",
+                issue_module__module_id=OuterRef("pk"),
+                issue_module__deleted_at__isnull=True,
+            )
+            .values("issue_module__module_id")
+            .annotate(completed_estimate_points=Sum(Cast("estimate_point__value", FloatField())))
+            .values("completed_estimate_points")[:1]
+        )
+
+        total_estimate_point = (
+            Issue.issue_objects.filter(
+                estimate_point__estimate__type="points",
+                issue_module__module_id=OuterRef("pk"),
+                issue_module__deleted_at__isnull=True,
+            )
+            .values("issue_module__module_id")
+            .annotate(total_estimate_points=Sum(Cast("estimate_point__value", FloatField())))
+            .values("total_estimate_points")[:1]
+        )
+        backlog_estimate_point = (
+            Issue.issue_objects.filter(
+                estimate_point__estimate__type="points",
+                state__group="backlog",
+                issue_module__module_id=OuterRef("pk"),
+                issue_module__deleted_at__isnull=True,
+            )
+            .values("issue_module__module_id")
+            .annotate(backlog_estimate_point=Sum(Cast("estimate_point__value", FloatField())))
+            .values("backlog_estimate_point")[:1]
+        )
+        unstarted_estimate_point = (
+            Issue.issue_objects.filter(
+                estimate_point__estimate__type="points",
+                state__group="unstarted",
+                issue_module__module_id=OuterRef("pk"),
+                issue_module__deleted_at__isnull=True,
+            )
+            .values("issue_module__module_id")
+            .annotate(unstarted_estimate_point=Sum(Cast("estimate_point__value", FloatField())))
+            .values("unstarted_estimate_point")[:1]
+        )
+        started_estimate_point = (
+            Issue.issue_objects.filter(
+                estimate_point__estimate__type="points",
+                state__group="started",
+                issue_module__module_id=OuterRef("pk"),
+                issue_module__deleted_at__isnull=True,
+            )
+            .values("issue_module__module_id")
+            .annotate(started_estimate_point=Sum(Cast("estimate_point__value", FloatField())))
+            .values("started_estimate_point")[:1]
+        )
+        cancelled_estimate_point = (
+            Issue.issue_objects.filter(
+                estimate_point__estimate__type="points",
+                state__group="cancelled",
+                issue_module__module_id=OuterRef("pk"),
+                issue_module__deleted_at__isnull=True,
+            )
+            .values("issue_module__module_id")
+            .annotate(cancelled_estimate_point=Sum(Cast("estimate_point__value", FloatField())))
+            .values("cancelled_estimate_point")[:1]
+        )
+        return (
+            super()
+            .get_queryset()
+            .filter(project_id=self.kwargs.get("project_id"))
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .annotate(is_favorite=Exists(favorite_subquery))
+            .prefetch_related("members")
+            .prefetch_related(
+                Prefetch(
+                    "link_module",
+                    queryset=ModuleLink.objects.select_related("module", "created_by"),
+                )
+            )
+            .annotate(
+                completed_issues=Coalesce(
+                    Subquery(completed_issues[:1]),
+                    Value(0, output_field=IntegerField()),
+                )
+            )
+            .annotate(
+                cancelled_issues=Coalesce(
+                    Subquery(cancelled_issues[:1]),
+                    Value(0, output_field=IntegerField()),
+                )
+            )
+            .annotate(started_issues=Coalesce(Subquery(started_issues[:1]), Value(0, output_field=IntegerField())))
+            .annotate(
+                unstarted_issues=Coalesce(
+                    Subquery(unstarted_issues[:1]),
+                    Value(0, output_field=IntegerField()),
+                )
+            )
+            .annotate(backlog_issues=Coalesce(Subquery(backlog_issues[:1]), Value(0, output_field=IntegerField())))
+            .annotate(total_issues=Coalesce(Subquery(total_issues[:1]), Value(0, output_field=IntegerField())))
+            .annotate(
+                backlog_estimate_points=Coalesce(
+                    Subquery(backlog_estimate_point),
+                    Value(0, output_field=FloatField()),
+                )
+            )
+            .annotate(
+                unstarted_estimate_points=Coalesce(
+                    Subquery(unstarted_estimate_point),
+                    Value(0, output_field=FloatField()),
+                )
+            )
+            .annotate(
+                started_estimate_points=Coalesce(
+                    Subquery(started_estimate_point),
+                    Value(0, output_field=FloatField()),
+                )
+            )
+            .annotate(
+                cancelled_estimate_points=Coalesce(
+                    Subquery(cancelled_estimate_point),
+                    Value(0, output_field=FloatField()),
+                )
+            )
+            .annotate(
+                completed_estimate_points=Coalesce(
+                    Subquery(completed_estimate_point),
+                    Value(0, output_field=FloatField()),
+                )
+            )
+            .annotate(
+                total_estimate_points=Coalesce(Subquery(total_estimate_point), Value(0, output_field=FloatField()))
+            )
+            .annotate(
+                member_ids=Coalesce(
+                    ArrayAgg(
+                        "members__id",
+                        distinct=True,
+                        filter=Q(
+                            members__id__isnull=False,
+                            modulemember__deleted_at__isnull=True,
+                        ),
+                    ),
+                    Value([], output_field=ArrayField(UUIDField())),
+                )
+            )
+            .order_by("-is_favorite", "-created_at")
+        )
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
+    def create(self, request, slug, project_id):
+        project = Project.objects.get(workspace__slug=slug, pk=project_id)
+        serializer = ModuleWriteSerializer(data=request.data, context={"project": project})
+
+        if serializer.is_valid():
+            serializer.save()
+
+            module = (
+                self.get_queryset()
+                .filter(pk=serializer.data["id"])
+                .values(  # Required fields
+                    "id",
+                    "workspace_id",
+                    "project_id",
+                    # Model fields
+                    "name",
+                    "description",
+                    "description_text",
+                    "description_html",
+                    "start_date",
+                    "target_date",
+                    "status",
+                    "lead_id",
+                    "member_ids",
+                    "view_props",
+                    "sort_order",
+                    "external_source",
+                    "external_id",
+                    "logo_props",
+                    # computed fields
+                    "is_favorite",
+                    "cancelled_issues",
+                    "completed_issues",
+                    "total_issues",
+                    "started_issues",
+                    "unstarted_issues",
+                    "completed_estimate_points",
+                    "total_estimate_points",
+                    "backlog_issues",
+                    "created_at",
+                    "updated_at",
+                )
+            ).first()
+            # Send the model activity
+            model_activity.delay(
+                model_name="module",
+                model_id=str(module["id"]),
+                requested_data=request.data,
+                current_instance=None,
+                actor_id=request.user.id,
+                slug=slug,
+                origin=base_host(request=request, is_app=True),
+            )
+            datetime_fields = ["created_at", "updated_at"]
+            module = user_timezone_converter(module, datetime_fields, request.user.user_timezone)
+            return Response(module, status=status.HTTP_201_CREATED)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
+    def list(self, request, slug, project_id):
+        queryset = self.get_queryset().filter(archived_at__isnull=True)
+        if self.fields:
+            modules = ModuleSerializer(queryset, many=True, fields=self.fields).data
+        else:
+            modules = queryset.values(  # Required fields
+                "id",
+                "workspace_id",
+                "project_id",
+                # Model fields
+                "name",
+                "description",
+                "description_text",
+                "description_html",
+                "start_date",
+                "target_date",
+                "status",
+                "lead_id",
+                "member_ids",
+                "view_props",
+                "sort_order",
+                "external_source",
+                "external_id",
+                "logo_props",
+                # computed fields
+                "completed_estimate_points",
+                "total_estimate_points",
+                "total_issues",
+                "is_favorite",
+                "cancelled_issues",
+                "completed_issues",
+                "started_issues",
+                "unstarted_issues",
+                "backlog_issues",
+                "created_at",
+                "updated_at",
+            )
+            datetime_fields = ["created_at", "updated_at"]
+            modules = user_timezone_converter(modules, datetime_fields, request.user.user_timezone)
+        return Response(modules, status=status.HTTP_200_OK)
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
+    def retrieve(self, request, slug, project_id, pk):
+        queryset = (
+            self.get_queryset()
+            .filter(archived_at__isnull=True)
+            .filter(pk=pk)
+            .annotate(
+                sub_issues=Issue.issue_objects.filter(
+                    project_id=self.kwargs.get("project_id"),
+                    parent__isnull=False,
+                    issue_module__module_id=pk,
+                    issue_module__deleted_at__isnull=True,
+                )
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
+        )
+
+        if not queryset.exists():
+            return Response({"error": "Module not found"}, status=status.HTTP_404_NOT_FOUND)
+
+        estimate_type = Project.objects.filter(
+            workspace__slug=slug,
+            pk=project_id,
+            estimate__isnull=False,
+            estimate__type="points",
+        ).exists()
+
+        data = ModuleDetailSerializer(queryset.first()).data
+        modules = queryset.first()
+
+        data["estimate_distribution"] = {}
+
+        if estimate_type:
+            assignee_distribution = (
+                Issue.issue_objects.filter(
+                    issue_module__module_id=pk,
+                    issue_module__deleted_at__isnull=True,
+                    workspace__slug=slug,
+                    project_id=project_id,
+                )
+                .annotate(first_name=F("assignees__first_name"))
+                .annotate(last_name=F("assignees__last_name"))
+                .annotate(assignee_id=F("assignees__id"))
+                .annotate(display_name=F("assignees__display_name"))
+                .annotate(
+                    avatar_url=Case(
+                        # If `avatar_asset` exists, use it to generate the asset URL
+                        When(
+                            assignees__avatar_asset__isnull=False,
+                            then=Concat(
+                                Value("/api/assets/v2/static/"),
+                                "assignees__avatar_asset",  # Assuming avatar_asset has an id or relevant field
+                                Value("/"),
+                            ),
+                        ),
+                        # If `avatar_asset` is None, fall back to using `avatar` field directly
+                        When(
+                            assignees__avatar_asset__isnull=True,
+                            then="assignees__avatar",
+                        ),
+                        default=Value(None),
+                        output_field=models.CharField(),
+                    )
+                )
+                .values(
+                    "first_name",
+                    "last_name",
+                    "assignee_id",
+                    "avatar_url",
+                    "display_name",
+                )
+                .annotate(total_estimates=Sum(Cast("estimate_point__value", FloatField())))
+                .annotate(
+                    completed_estimates=Sum(
+                        Cast("estimate_point__value", FloatField()),
+                        filter=Q(
+                            completed_at__isnull=False,
+                            archived_at__isnull=True,
+                            is_draft=False,
+                        ),
+                    )
+                )
+                .annotate(
+                    pending_estimates=Sum(
+                        Cast("estimate_point__value", FloatField()),
+                        filter=Q(
+                            completed_at__isnull=True,
+                            archived_at__isnull=True,
+                            is_draft=False,
+                        ),
+                    )
+                )
+                .order_by("first_name", "last_name")
+            )
+
+            label_distribution = (
+                Issue.issue_objects.filter(
+                    issue_module__module_id=pk,
+                    issue_module__deleted_at__isnull=True,
+                    workspace__slug=slug,
+                    project_id=project_id,
+                )
+                .annotate(label_name=F("labels__name"))
+                .annotate(color=F("labels__color"))
+                .annotate(label_id=F("labels__id"))
+                .values("label_name", "color", "label_id")
+                .annotate(total_estimates=Sum(Cast("estimate_point__value", FloatField())))
+                .annotate(
+                    completed_estimates=Sum(
+                        Cast("estimate_point__value", FloatField()),
+                        filter=Q(
+                            completed_at__isnull=False,
+                            archived_at__isnull=True,
+                            is_draft=False,
+                        ),
+                    )
+                )
+                .annotate(
+                    pending_estimates=Sum(
+                        Cast("estimate_point__value", FloatField()),
+                        filter=Q(
+                            completed_at__isnull=True,
+                            archived_at__isnull=True,
+                            is_draft=False,
+                        ),
+                    )
+                )
+                .order_by("label_name")
+            )
+            data["estimate_distribution"]["assignees"] = assignee_distribution
+            data["estimate_distribution"]["labels"] = label_distribution
+
+            if modules and modules.start_date and modules.target_date:
+                data["estimate_distribution"]["completion_chart"] = burndown_plot(
+                    queryset=modules,
+                    slug=slug,
+                    project_id=project_id,
+                    plot_type="points",
+                    module_id=pk,
+                )
+
+        assignee_distribution = (
+            Issue.issue_objects.filter(
+                issue_module__module_id=pk,
+                issue_module__deleted_at__isnull=True,
+                workspace__slug=slug,
+                project_id=project_id,
+            )
+            .annotate(first_name=F("assignees__first_name"))
+            .annotate(last_name=F("assignees__last_name"))
+            .annotate(assignee_id=F("assignees__id"))
+            .annotate(display_name=F("assignees__display_name"))
+            .annotate(
+                avatar_url=Case(
+                    # If `avatar_asset` exists, use it to generate the asset URL
+                    When(
+                        assignees__avatar_asset__isnull=False,
+                        then=Concat(
+                            Value("/api/assets/v2/static/"),
+                            "assignees__avatar_asset",  # Assuming avatar_asset has an id or relevant field
+                            Value("/"),
+                        ),
+                    ),
+                    # If `avatar_asset` is None, fall back to using `avatar` field directly
+                    When(assignees__avatar_asset__isnull=True, then="assignees__avatar"),
+                    default=Value(None),
+                    output_field=models.CharField(),
+                )
+            )
+            .values("first_name", "last_name", "assignee_id", "avatar_url", "display_name")
+            .annotate(total_issues=Count("id", filter=Q(archived_at__isnull=True, is_draft=False)))
+            .annotate(
+                completed_issues=Count(
+                    "id",
+                    filter=Q(
+                        completed_at__isnull=False,
+                        archived_at__isnull=True,
+                        is_draft=False,
+                    ),
+                )
+            )
+            .annotate(
+                pending_issues=Count(
+                    "id",
+                    filter=Q(
+                        completed_at__isnull=True,
+                        archived_at__isnull=True,
+                        is_draft=False,
+                    ),
+                )
+            )
+            .order_by("first_name", "last_name")
+        )
+
+        label_distribution = (
+            Issue.issue_objects.filter(
+                issue_module__module_id=pk,
+                issue_module__deleted_at__isnull=True,
+                workspace__slug=slug,
+                project_id=project_id,
+            )
+            .annotate(label_name=F("labels__name"))
+            .annotate(color=F("labels__color"))
+            .annotate(label_id=F("labels__id"))
+            .values("label_name", "color", "label_id")
+            .annotate(total_issues=Count("id", filter=Q(archived_at__isnull=True, is_draft=False)))
+            .annotate(
+                completed_issues=Count(
+                    "id",
+                    filter=Q(
+                        completed_at__isnull=False,
+                        archived_at__isnull=True,
+                        is_draft=False,
+                    ),
+                )
+            )
+            .annotate(
+                pending_issues=Count(
+                    "id",
+                    filter=Q(
+                        completed_at__isnull=True,
+                        archived_at__isnull=True,
+                        is_draft=False,
+                    ),
+                )
+            )
+            .order_by("label_name")
+        )
+
+        data["distribution"] = {
+            "assignees": assignee_distribution,
+            "labels": label_distribution,
+            "completion_chart": {},
+        }
+
+        if modules and modules.start_date and modules.target_date and modules.total_issues > 0:
+            data["distribution"]["completion_chart"] = burndown_plot(
+                queryset=modules,
+                slug=slug,
+                project_id=project_id,
+                plot_type="issues",
+                module_id=pk,
+            )
+
+        recent_visited_task.delay(
+            slug=slug,
+            entity_name="module",
+            entity_identifier=pk,
+            user_id=request.user.id,
+            project_id=project_id,
+        )
+
+        return Response(data, status=status.HTTP_200_OK)
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
+    def partial_update(self, request, slug, project_id, pk):
+        module_queryset = self.get_queryset().filter(pk=pk)
+
+        current_module = module_queryset.first()
+
+        if not current_module:
+            return Response(
+                {"error": "Module not found"},
+                status=status.HTTP_404_NOT_FOUND,
+            )
+
+        if current_module.archived_at:
+            return Response(
+                {"error": "Archived module cannot be updated"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+        current_instance = json.dumps(ModuleSerializer(current_module).data, cls=DjangoJSONEncoder)
+        serializer = ModuleWriteSerializer(current_module, data=request.data, partial=True)
+
+        if serializer.is_valid():
+            serializer.save()
+            module = module_queryset.values(
+                # Required fields
+                "id",
+                "workspace_id",
+                "project_id",
+                # Model fields
+                "name",
+                "description",
+                "description_text",
+                "description_html",
+                "start_date",
+                "target_date",
+                "status",
+                "lead_id",
+                "member_ids",
+                "view_props",
+                "sort_order",
+                "external_source",
+                "external_id",
+                "logo_props",
+                # computed fields
+                "completed_estimate_points",
+                "total_estimate_points",
+                "is_favorite",
+                "cancelled_issues",
+                "completed_issues",
+                "started_issues",
+                "total_issues",
+                "unstarted_issues",
+                "backlog_issues",
+                "created_at",
+                "updated_at",
+            ).first()
+
+            # Send the model activity
+            model_activity.delay(
+                model_name="module",
+                model_id=str(module["id"]),
+                requested_data=request.data,
+                current_instance=current_instance,
+                actor_id=request.user.id,
+                slug=slug,
+                origin=base_host(request=request, is_app=True),
+            )
+
+            datetime_fields = ["created_at", "updated_at"]
+            module = user_timezone_converter(module, datetime_fields, request.user.user_timezone)
+            return Response(module, status=status.HTTP_200_OK)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    @allow_permission([ROLE.ADMIN], creator=True, model=Module)
+    def destroy(self, request, slug, project_id, pk):
+        module = Module.objects.get(workspace__slug=slug, project_id=project_id, pk=pk)
+
+        module_issues = list(ModuleIssue.objects.filter(module_id=pk).values_list("issue", flat=True))
+        _ = [
+            issue_activity.delay(
+                type="module.activity.deleted",
+                requested_data=json.dumps({"module_id": str(pk)}),
+                actor_id=str(request.user.id),
+                issue_id=str(issue),
+                project_id=project_id,
+                current_instance=json.dumps({"module_name": str(module.name)}),
+                epoch=int(timezone.now().timestamp()),
+                notification=True,
+                origin=base_host(request=request, is_app=True),
+            )
+            for issue in module_issues
+        ]
+        module.delete()
+        # Delete the module issues
+        ModuleIssue.objects.filter(module=pk, project_id=project_id).delete()
+        # Delete the user favorite module
+        UserFavorite.objects.filter(
+            user=request.user,
+            entity_type="module",
+            entity_identifier=pk,
+            project_id=project_id,
+        ).delete()
+        # delete the module from recent visits
+        UserRecentVisit.objects.filter(
+            project_id=project_id,
+            workspace__slug=slug,
+            entity_identifier=pk,
+            entity_name="module",
+        ).delete(soft=False)
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+class ModuleLinkViewSet(BaseViewSet):
+    permission_classes = [ProjectEntityPermission]
+
+    model = ModuleLink
+    serializer_class = ModuleLinkSerializer
+
+    def perform_create(self, serializer):
+        serializer.save(
+            project_id=self.kwargs.get("project_id"),
+            module_id=self.kwargs.get("module_id"),
+        )
+
+    def get_queryset(self):
+        return (
+            super()
+            .get_queryset()
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .filter(project_id=self.kwargs.get("project_id"))
+            .filter(module_id=self.kwargs.get("module_id"))
+            .filter(
+                project__project_projectmember__member=self.request.user,
+                project__project_projectmember__is_active=True,
+                project__archived_at__isnull=True,
+            )
+            .order_by("-created_at")
+            .distinct()
+        )
+
+
+class ModuleFavoriteViewSet(BaseViewSet):
+    model = UserFavorite
+    permission_classes = [ProjectLitePermission]
+
+    def get_queryset(self):
+        return self.filter_queryset(
+            super()
+            .get_queryset()
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .filter(user=self.request.user)
+            .select_related("module")
+        )
+
+    def create(self, request, slug, project_id):
+        _ = UserFavorite.objects.create(
+            project_id=project_id,
+            user=request.user,
+            entity_type="module",
+            entity_identifier=request.data.get("module"),
+        )
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+    def destroy(self, request, slug, project_id, module_id):
+        module_favorite = UserFavorite.objects.get(
+            project_id=project_id,
+            user=request.user,
+            workspace__slug=slug,
+            entity_type="module",
+            entity_identifier=module_id,
+        )
+        module_favorite.delete(soft=False)
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+class ModuleUserPropertiesEndpoint(BaseAPIView):
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
+    def patch(self, request, slug, project_id, module_id):
+        module_properties = ModuleUserProperties.objects.get(
+            user=request.user,
+            module_id=module_id,
+            project_id=project_id,
+            workspace__slug=slug,
+        )
+
+        module_properties.filters = request.data.get("filters", module_properties.filters)
+        module_properties.rich_filters = request.data.get("rich_filters", module_properties.rich_filters)
+        module_properties.display_filters = request.data.get("display_filters", module_properties.display_filters)
+        module_properties.display_properties = request.data.get(
+            "display_properties", module_properties.display_properties
+        )
+        module_properties.save()
+
+        serializer = ModuleUserPropertiesSerializer(module_properties)
+        return Response(serializer.data, status=status.HTTP_201_CREATED)
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
+    def get(self, request, slug, project_id, module_id):
+        module_properties, _ = ModuleUserProperties.objects.get_or_create(
+            user=request.user,
+            project_id=project_id,
+            module_id=module_id,
+            workspace__slug=slug,
+        )
+        serializer = ModuleUserPropertiesSerializer(module_properties)
+        return Response(serializer.data, status=status.HTTP_200_OK)

plane-src/apps/api/plane/app/views/module/issue.py

@@ -0,0 +1,337 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+# Python imports
+import copy
+import json
+
+from django.db.models import F, Func, OuterRef, Q, Subquery
+
+# Django Imports
+from django.utils import timezone
+from django.utils.decorators import method_decorator
+from django.views.decorators.gzip import gzip_page
+
+# Third party imports
+from rest_framework import status
+from rest_framework.response import Response
+
+from plane.app.permissions import allow_permission, ROLE
+from plane.app.serializers import ModuleIssueSerializer
+from plane.bgtasks.issue_activities_task import issue_activity
+from plane.db.models import (
+    Issue,
+    FileAsset,
+    IssueLink,
+    ModuleIssue,
+    Project,
+    CycleIssue,
+)
+from plane.utils.grouper import (
+    issue_group_values,
+    issue_on_results,
+    issue_queryset_grouper,
+)
+from plane.utils.issue_filters import issue_filters
+from plane.utils.order_queryset import order_issue_queryset
+from plane.utils.paginator import GroupedOffsetPaginator, SubGroupedOffsetPaginator
+from plane.utils.filters import ComplexFilterBackend
+from plane.utils.filters import IssueFilterSet
+from .. import BaseViewSet
+from plane.utils.host import base_host
+
+
+class ModuleIssueViewSet(BaseViewSet):
+    serializer_class = ModuleIssueSerializer
+    model = ModuleIssue
+    webhook_event = "module_issue"
+    bulk = True
+    filter_backends = (ComplexFilterBackend,)
+    filterset_class = IssueFilterSet
+
+    def apply_annotations(self, issues):
+        return (
+            issues.annotate(
+                cycle_id=Subquery(
+                    CycleIssue.objects.filter(issue=OuterRef("id"), deleted_at__isnull=True).values("cycle_id")[:1]
+                )
+            )
+            .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")
+            )
+            .annotate(
+                sub_issues_count=Issue.issue_objects.filter(parent=OuterRef("id"))
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
+            .prefetch_related("assignees", "labels", "issue_module__module")
+        )
+
+    def get_queryset(self):
+        return (
+            Issue.issue_objects.filter(
+                project_id=self.kwargs.get("project_id"),
+                workspace__slug=self.kwargs.get("slug"),
+                issue_module__module_id=self.kwargs.get("module_id"),
+                issue_module__deleted_at__isnull=True,
+            )
+        ).distinct()
+
+    @method_decorator(gzip_page)
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
+    def list(self, request, slug, project_id, module_id):
+        filters = issue_filters(request.query_params, "GET")
+        issue_queryset = self.get_queryset()
+
+        # Apply filtering from filterset
+        issue_queryset = self.filter_queryset(issue_queryset)
+
+        # Apply legacy filters
+        issue_queryset = issue_queryset.filter(**filters)
+
+        # Total count queryset
+        total_issue_queryset = copy.deepcopy(issue_queryset)
+
+        # Apply annotations to the issue queryset
+        issue_queryset = self.apply_annotations(issue_queryset)
+
+        order_by_param = request.GET.get("order_by", "created_at")
+
+        # Issue queryset
+        issue_queryset, order_by_param = order_issue_queryset(
+            issue_queryset=issue_queryset, order_by_param=order_by_param
+        )
+
+        # Group by
+        group_by = request.GET.get("group_by", False)
+        sub_group_by = request.GET.get("sub_group_by", False)
+
+        # issue queryset
+        issue_queryset = issue_queryset_grouper(queryset=issue_queryset, group_by=group_by, sub_group_by=sub_group_by)
+
+        if group_by:
+            # Check group and sub group value paginate
+            if sub_group_by:
+                if group_by == sub_group_by:
+                    return Response(
+                        {"error": "Group by and sub group by cannot have same parameters"},
+                        status=status.HTTP_400_BAD_REQUEST,
+                    )
+                else:
+                    # group and sub group pagination
+                    return self.paginate(
+                        request=request,
+                        order_by=order_by_param,
+                        queryset=issue_queryset,
+                        total_count_queryset=total_issue_queryset,
+                        on_results=lambda issues: issue_on_results(
+                            group_by=group_by, issues=issues, sub_group_by=sub_group_by
+                        ),
+                        paginator_cls=SubGroupedOffsetPaginator,
+                        group_by_fields=issue_group_values(
+                            field=group_by,
+                            slug=slug,
+                            project_id=project_id,
+                            filters=filters,
+                            queryset=total_issue_queryset,
+                        ),
+                        sub_group_by_fields=issue_group_values(
+                            field=sub_group_by,
+                            slug=slug,
+                            project_id=project_id,
+                            filters=filters,
+                            queryset=total_issue_queryset,
+                        ),
+                        group_by_field_name=group_by,
+                        sub_group_by_field_name=sub_group_by,
+                        count_filter=Q(
+                            Q(issue_intake__status=1)
+                            | Q(issue_intake__status=-1)
+                            | Q(issue_intake__status=2)
+                            | Q(issue_intake__isnull=True),
+                            archived_at__isnull=True,
+                            is_draft=False,
+                        ),
+                    )
+            # Group Paginate
+            else:
+                # Group paginate
+                return self.paginate(
+                    request=request,
+                    order_by=order_by_param,
+                    queryset=issue_queryset,
+                    total_count_queryset=total_issue_queryset,
+                    on_results=lambda issues: issue_on_results(
+                        group_by=group_by, issues=issues, sub_group_by=sub_group_by
+                    ),
+                    paginator_cls=GroupedOffsetPaginator,
+                    group_by_fields=issue_group_values(
+                        field=group_by,
+                        slug=slug,
+                        project_id=project_id,
+                        filters=filters,
+                        queryset=total_issue_queryset,
+                    ),
+                    group_by_field_name=group_by,
+                    count_filter=Q(
+                        Q(issue_intake__status=1)
+                        | Q(issue_intake__status=-1)
+                        | Q(issue_intake__status=2)
+                        | Q(issue_intake__isnull=True),
+                        archived_at__isnull=True,
+                        is_draft=False,
+                    ),
+                )
+        else:
+            # List Paginate
+            return self.paginate(
+                order_by=order_by_param,
+                request=request,
+                queryset=issue_queryset,
+                total_count_queryset=total_issue_queryset,
+                on_results=lambda issues: issue_on_results(group_by=group_by, issues=issues, sub_group_by=sub_group_by),
+            )
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
+    # create multiple issues inside a module
+    def create_module_issues(self, request, slug, project_id, module_id):
+        issues = request.data.get("issues", [])
+        if not issues:
+            return Response({"error": "Issues are required"}, status=status.HTTP_400_BAD_REQUEST)
+        project = Project.objects.get(pk=project_id)
+        _ = ModuleIssue.objects.bulk_create(
+            [
+                ModuleIssue(
+                    issue_id=str(issue),
+                    module_id=module_id,
+                    project_id=project_id,
+                    workspace_id=project.workspace_id,
+                    created_by=request.user,
+                    updated_by=request.user,
+                )
+                for issue in issues
+            ],
+            batch_size=10,
+            ignore_conflicts=True,
+        )
+        # Bulk Update the activity
+        _ = [
+            issue_activity.delay(
+                type="module.activity.created",
+                requested_data=json.dumps({"module_id": str(module_id)}),
+                actor_id=str(request.user.id),
+                issue_id=str(issue),
+                project_id=project_id,
+                current_instance=None,
+                epoch=int(timezone.now().timestamp()),
+                notification=True,
+                origin=base_host(request=request, is_app=True),
+            )
+            for issue in issues
+        ]
+        return Response({"message": "success"}, status=status.HTTP_201_CREATED)
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
+    # add multiple module inside an issue and remove multiple modules from an issue
+    def create_issue_modules(self, request, slug, project_id, issue_id):
+        modules = request.data.get("modules", [])
+        removed_modules = request.data.get("removed_modules", [])
+        project = Project.objects.get(pk=project_id)
+
+        if modules:
+            _ = ModuleIssue.objects.bulk_create(
+                [
+                    ModuleIssue(
+                        issue_id=issue_id,
+                        module_id=module,
+                        project_id=project_id,
+                        workspace_id=project.workspace_id,
+                        created_by=request.user,
+                        updated_by=request.user,
+                    )
+                    for module in modules
+                ],
+                batch_size=10,
+                ignore_conflicts=True,
+            )
+            # Bulk Update the activity
+            _ = [
+                issue_activity.delay(
+                    type="module.activity.created",
+                    requested_data=json.dumps({"module_id": module}),
+                    actor_id=str(request.user.id),
+                    issue_id=issue_id,
+                    project_id=project_id,
+                    current_instance=None,
+                    epoch=int(timezone.now().timestamp()),
+                    notification=True,
+                    origin=base_host(request=request, is_app=True),
+                )
+                for module in modules
+            ]
+
+        for module_id in removed_modules:
+            module_issue = ModuleIssue.objects.filter(
+                workspace__slug=slug,
+                project_id=project_id,
+                module_id=module_id,
+                issue_id=issue_id,
+            )
+            issue_activity.delay(
+                type="module.activity.deleted",
+                requested_data=json.dumps({"module_id": str(module_id)}),
+                actor_id=str(request.user.id),
+                issue_id=str(issue_id),
+                project_id=str(project_id),
+                current_instance=json.dumps(
+                    {
+                        "module_name": (
+                            module_issue.first().module.name
+                            if (module_issue.first() and module_issue.first().module)
+                            else None
+                        )
+                    }
+                ),
+                epoch=int(timezone.now().timestamp()),
+                notification=True,
+                origin=base_host(request=request, is_app=True),
+            )
+            module_issue.delete()
+
+        return Response({"message": "success"}, status=status.HTTP_201_CREATED)
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
+    def destroy(self, request, slug, project_id, module_id, issue_id):
+        module_issue = ModuleIssue.objects.filter(
+            workspace__slug=slug,
+            project_id=project_id,
+            module_id=module_id,
+            issue_id=issue_id,
+        )
+        issue_activity.delay(
+            type="module.activity.deleted",
+            requested_data=json.dumps({"module_id": str(module_id)}),
+            actor_id=str(request.user.id),
+            issue_id=str(issue_id),
+            project_id=str(project_id),
+            current_instance=json.dumps({"module_name": module_issue.first().module.name}),
+            epoch=int(timezone.now().timestamp()),
+            notification=True,
+            origin=base_host(request=request, is_app=True),
+        )
+        module_issue.delete()
+        return Response(status=status.HTTP_204_NO_CONTENT)

plane-src/apps/api/plane/app/views/notification/base.py

@@ -0,0 +1,308 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+# Django imports
+from django.db.models import Exists, OuterRef, Q, Case, When, BooleanField
+from django.utils import timezone
+
+# Third party imports
+from rest_framework import status
+from rest_framework.response import Response
+
+from plane.app.serializers import (
+    NotificationSerializer,
+    UserNotificationPreferenceSerializer,
+)
+from plane.db.models import (
+    Issue,
+    IssueAssignee,
+    IssueSubscriber,
+    Notification,
+    UserNotificationPreference,
+    WorkspaceMember,
+)
+from plane.utils.paginator import BasePaginator
+from plane.app.permissions import allow_permission, ROLE
+
+# Module imports
+from ..base import BaseAPIView, BaseViewSet
+
+
+class NotificationViewSet(BaseViewSet, BasePaginator):
+    model = Notification
+    serializer_class = NotificationSerializer
+
+    def get_queryset(self):
+        return (
+            super()
+            .get_queryset()
+            .filter(
+                workspace__slug=self.kwargs.get("slug"),
+                receiver_id=self.request.user.id,
+            )
+            .select_related("workspace", "project", "triggered_by", "receiver")
+        )
+
+    @allow_permission(allowed_roles=[ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], level="WORKSPACE")
+    def list(self, request, slug):
+        # Get query parameters
+        snoozed = request.GET.get("snoozed", "false")
+        archived = request.GET.get("archived", "false")
+        read = request.GET.get("read", None)
+        type = request.GET.get("type", "all")
+        mentioned = request.GET.get("mentioned", False)
+        q_filters = Q()
+
+        intake_issue = Issue.objects.filter(
+            pk=OuterRef("entity_identifier"),
+            issue_intake__status__in=[0, 2, -2],
+            workspace__slug=self.kwargs.get("slug"),
+        )
+
+        notifications = (
+            Notification.objects.filter(workspace__slug=slug, receiver_id=request.user.id)
+            .filter(entity_name="issue")
+            .annotate(is_inbox_issue=Exists(intake_issue))
+            .annotate(is_intake_issue=Exists(intake_issue))
+            .annotate(
+                is_mentioned_notification=Case(
+                    When(sender__icontains="mentioned", then=True),
+                    default=False,
+                    output_field=BooleanField(),
+                )
+            )
+            .select_related("workspace", "project", "triggered_by", "receiver")
+            .order_by("snoozed_till", "-created_at")
+        )
+
+        # Filters based on query parameters
+        snoozed_filters = {
+            "true": Q(snoozed_till__lt=timezone.now()) | Q(snoozed_till__isnull=False),
+            "false": Q(snoozed_till__gte=timezone.now()) | Q(snoozed_till__isnull=True),
+        }
+
+        notifications = notifications.filter(snoozed_filters[snoozed])
+
+        archived_filters = {
+            "true": Q(archived_at__isnull=False),
+            "false": Q(archived_at__isnull=True),
+        }
+
+        notifications = notifications.filter(archived_filters[archived])
+
+        if read == "false":
+            notifications = notifications.filter(read_at__isnull=True)
+
+        if read == "true":
+            notifications = notifications.filter(read_at__isnull=False)
+
+        if mentioned:
+            notifications = notifications.filter(sender__icontains="mentioned")
+        else:
+            notifications = notifications.exclude(sender__icontains="mentioned")
+
+        type = type.split(",")
+        # Subscribed issues
+        if "subscribed" in type:
+            issue_ids = (
+                IssueSubscriber.objects.filter(workspace__slug=slug, subscriber_id=request.user.id)
+                .annotate(created=Exists(Issue.objects.filter(created_by=request.user, pk=OuterRef("issue_id"))))
+                .annotate(assigned=Exists(IssueAssignee.objects.filter(pk=OuterRef("issue_id"), assignee=request.user)))
+                .filter(created=False, assigned=False)
+                .values_list("issue_id", flat=True)
+            )
+            q_filters |= Q(entity_identifier__in=issue_ids)
+
+        # Assigned Issues
+        if "assigned" in type:
+            issue_ids = IssueAssignee.objects.filter(workspace__slug=slug, assignee_id=request.user.id).values_list(
+                "issue_id", flat=True
+            )
+            q_filters |= Q(entity_identifier__in=issue_ids)
+
+        # Created issues
+        if "created" in type:
+            if WorkspaceMember.objects.filter(
+                workspace__slug=slug, member=request.user, role__lt=15, is_active=True
+            ).exists():
+                notifications = notifications.none()
+            else:
+                issue_ids = Issue.objects.filter(workspace__slug=slug, created_by=request.user).values_list(
+                    "pk", flat=True
+                )
+                q_filters |= Q(entity_identifier__in=issue_ids)
+
+        # Apply the combined Q object filters
+        notifications = notifications.filter(q_filters)
+
+        # Pagination
+        if request.GET.get("per_page", False) and request.GET.get("cursor", False):
+            return self.paginate(
+                order_by=request.GET.get("order_by", "-created_at"),
+                request=request,
+                queryset=(notifications),
+                on_results=lambda notifications: NotificationSerializer(notifications, many=True).data,
+            )
+
+        serializer = NotificationSerializer(notifications, many=True)
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+    @allow_permission(allowed_roles=[ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], level="WORKSPACE")
+    def partial_update(self, request, slug, pk):
+        notification = Notification.objects.get(workspace__slug=slug, pk=pk, receiver=request.user)
+        # Only read_at and snoozed_till can be updated
+        notification_data = {"snoozed_till": request.data.get("snoozed_till", None)}
+        serializer = NotificationSerializer(notification, data=notification_data, partial=True)
+
+        if serializer.is_valid():
+            serializer.save()
+            return Response(serializer.data, status=status.HTTP_200_OK)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    @allow_permission(allowed_roles=[ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], level="WORKSPACE")
+    def mark_read(self, request, slug, pk):
+        notification = Notification.objects.get(receiver=request.user, workspace__slug=slug, pk=pk)
+        notification.read_at = timezone.now()
+        notification.save()
+        serializer = NotificationSerializer(notification)
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+    @allow_permission(allowed_roles=[ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], level="WORKSPACE")
+    def mark_unread(self, request, slug, pk):
+        notification = Notification.objects.get(receiver=request.user, workspace__slug=slug, pk=pk)
+        notification.read_at = None
+        notification.save()
+        serializer = NotificationSerializer(notification)
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+    @allow_permission(allowed_roles=[ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], level="WORKSPACE")
+    def archive(self, request, slug, pk):
+        notification = Notification.objects.get(receiver=request.user, workspace__slug=slug, pk=pk)
+        notification.archived_at = timezone.now()
+        notification.save()
+        serializer = NotificationSerializer(notification)
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+    @allow_permission(allowed_roles=[ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], level="WORKSPACE")
+    def unarchive(self, request, slug, pk):
+        notification = Notification.objects.get(receiver=request.user, workspace__slug=slug, pk=pk)
+        notification.archived_at = None
+        notification.save()
+        serializer = NotificationSerializer(notification)
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+
+class UnreadNotificationEndpoint(BaseAPIView):
+    use_read_replica = True
+
+    @allow_permission(allowed_roles=[ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], level="WORKSPACE")
+    def get(self, request, slug):
+        # Watching Issues Count
+        unread_notifications_count = (
+            Notification.objects.filter(
+                workspace__slug=slug,
+                receiver_id=request.user.id,
+                read_at__isnull=True,
+                archived_at__isnull=True,
+                snoozed_till__isnull=True,
+            )
+            .exclude(sender__icontains="mentioned")
+            .count()
+        )
+
+        mention_notifications_count = Notification.objects.filter(
+            workspace__slug=slug,
+            receiver_id=request.user.id,
+            read_at__isnull=True,
+            archived_at__isnull=True,
+            snoozed_till__isnull=True,
+            sender__icontains="mentioned",
+        ).count()
+
+        return Response(
+            {
+                "total_unread_notifications_count": int(unread_notifications_count),
+                "mention_unread_notifications_count": int(mention_notifications_count),
+            },
+            status=status.HTTP_200_OK,
+        )
+
+
+class MarkAllReadNotificationViewSet(BaseViewSet):
+    @allow_permission(allowed_roles=[ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], level="WORKSPACE")
+    def create(self, request, slug):
+        snoozed = request.data.get("snoozed", False)
+        archived = request.data.get("archived", False)
+        type = request.data.get("type", "all")
+
+        notifications = (
+            Notification.objects.filter(workspace__slug=slug, receiver_id=request.user.id, read_at__isnull=True)
+            .select_related("workspace", "project", "triggered_by", "receiver")
+            .order_by("snoozed_till", "-created_at")
+        )
+
+        # Filter for snoozed notifications
+        if snoozed:
+            notifications = notifications.filter(Q(snoozed_till__lt=timezone.now()) | Q(snoozed_till__isnull=False))
+        else:
+            notifications = notifications.filter(Q(snoozed_till__gte=timezone.now()) | Q(snoozed_till__isnull=True))
+
+        # Filter for archived or unarchive
+        if archived:
+            notifications = notifications.filter(archived_at__isnull=False)
+        else:
+            notifications = notifications.filter(archived_at__isnull=True)
+
+        # Subscribed issues
+        if type == "watching":
+            issue_ids = IssueSubscriber.objects.filter(workspace__slug=slug, subscriber_id=request.user.id).values_list(
+                "issue_id", flat=True
+            )
+            notifications = notifications.filter(entity_identifier__in=issue_ids)
+
+        # Assigned Issues
+        if type == "assigned":
+            issue_ids = IssueAssignee.objects.filter(workspace__slug=slug, assignee_id=request.user.id).values_list(
+                "issue_id", flat=True
+            )
+            notifications = notifications.filter(entity_identifier__in=issue_ids)
+
+        # Created issues
+        if type == "created":
+            if WorkspaceMember.objects.filter(
+                workspace__slug=slug, member=request.user, role__lt=15, is_active=True
+            ).exists():
+                notifications = Notification.objects.none()
+            else:
+                issue_ids = Issue.objects.filter(workspace__slug=slug, created_by=request.user).values_list(
+                    "pk", flat=True
+                )
+                notifications = notifications.filter(entity_identifier__in=issue_ids)
+
+        updated_notifications = []
+        for notification in notifications:
+            notification.read_at = timezone.now()
+            updated_notifications.append(notification)
+        Notification.objects.bulk_update(updated_notifications, ["read_at"], batch_size=100)
+        return Response({"message": "Successful"}, status=status.HTTP_200_OK)
+
+
+class UserNotificationPreferenceEndpoint(BaseAPIView):
+    model = UserNotificationPreference
+    serializer_class = UserNotificationPreferenceSerializer
+
+    # request the object
+    def get(self, request):
+        user_notification_preference = UserNotificationPreference.objects.get(user=request.user)
+        serializer = UserNotificationPreferenceSerializer(user_notification_preference)
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+    # update the object
+    def patch(self, request):
+        user_notification_preference = UserNotificationPreference.objects.get(user=request.user)
+        serializer = UserNotificationPreferenceSerializer(user_notification_preference, data=request.data, partial=True)
+        if serializer.is_valid():
+            serializer.save()
+            return Response(serializer.data, status=status.HTTP_200_OK)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

plane-src/apps/api/plane/app/views/page/base.py

@@ -0,0 +1,639 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+# Python imports
+import json
+from datetime import datetime
+from django.core.serializers.json import DjangoJSONEncoder
+
+# Django imports
+from django.db import connection
+from django.db.models import (
+    Exists,
+    OuterRef,
+    Q,
+    Value,
+    UUIDField,
+    Count,
+    Case,
+    When,
+    IntegerField,
+)
+from django.http import StreamingHttpResponse
+from django.contrib.postgres.aggregates import ArrayAgg
+from django.contrib.postgres.fields import ArrayField
+from django.db.models.functions import Coalesce
+
+# Third party imports
+from rest_framework import status
+from rest_framework.response import Response
+
+# Module imports
+from plane.app.permissions import allow_permission, ROLE
+from plane.app.serializers import (
+    PageSerializer,
+    PageDetailSerializer,
+    PageBinaryUpdateSerializer,
+)
+from plane.db.models import (
+    Page,
+    PageLog,
+    UserFavorite,
+    ProjectMember,
+    ProjectPage,
+    Project,
+    UserRecentVisit,
+)
+from plane.utils.error_codes import ERROR_CODES
+
+# Local imports
+from ..base import BaseAPIView, BaseViewSet
+from plane.bgtasks.page_transaction_task import page_transaction
+from plane.bgtasks.page_version_task import track_page_version
+from plane.bgtasks.recent_visited_task import recent_visited_task
+from plane.bgtasks.copy_s3_object import copy_s3_objects_of_description_and_assets
+from plane.app.permissions import ProjectPagePermission
+
+
+def unarchive_archive_page_and_descendants(page_id, archived_at):
+    # Your SQL query
+    sql = """
+    WITH RECURSIVE descendants AS (
+        SELECT id FROM pages WHERE id = %s
+        UNION ALL
+        SELECT pages.id FROM pages, descendants WHERE pages.parent_id = descendants.id
+    )
+    UPDATE pages SET archived_at = %s WHERE id IN (SELECT id FROM descendants);
+    """
+
+    # Execute the SQL query
+    with connection.cursor() as cursor:
+        cursor.execute(sql, [page_id, archived_at])
+
+
+class PageViewSet(BaseViewSet):
+    serializer_class = PageSerializer
+    model = Page
+    permission_classes = [ProjectPagePermission]
+    search_fields = ["name"]
+
+    def get_queryset(self):
+        subquery = UserFavorite.objects.filter(
+            user=self.request.user,
+            entity_type="page",
+            entity_identifier=OuterRef("pk"),
+            workspace__slug=self.kwargs.get("slug"),
+        )
+        return self.filter_queryset(
+            super()
+            .get_queryset()
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .filter(
+                projects__project_projectmember__member=self.request.user,
+                projects__project_projectmember__is_active=True,
+                projects__archived_at__isnull=True,
+            )
+            .filter(parent__isnull=True)
+            .filter(Q(owned_by=self.request.user) | Q(access=0))
+            .prefetch_related("projects")
+            .select_related("workspace")
+            .select_related("owned_by")
+            .annotate(is_favorite=Exists(subquery))
+            .order_by(self.request.GET.get("order_by", "-created_at"))
+            .prefetch_related("labels")
+            .order_by("-is_favorite", "-created_at")
+            .annotate(
+                project=Exists(
+                    ProjectPage.objects.filter(page_id=OuterRef("id"), project_id=self.kwargs.get("project_id"))
+                )
+            )
+            .annotate(
+                label_ids=Coalesce(
+                    ArrayAgg(
+                        "page_labels__label_id",
+                        distinct=True,
+                        filter=~Q(page_labels__label_id__isnull=True),
+                    ),
+                    Value([], output_field=ArrayField(UUIDField())),
+                ),
+                project_ids=Coalesce(
+                    ArrayAgg("projects__id", distinct=True, filter=~Q(projects__id=True)),
+                    Value([], output_field=ArrayField(UUIDField())),
+                ),
+            )
+            .filter(project=True)
+            .distinct()
+        )
+
+    def create(self, request, slug, project_id):
+        serializer = PageSerializer(
+            data=request.data,
+            context={
+                "project_id": project_id,
+                "owned_by_id": request.user.id,
+                "description_json": request.data.get("description_json", {}),
+                "description_binary": request.data.get("description_binary", None),
+                "description_html": request.data.get("description_html", "<p></p>"),
+            },
+        )
+
+        if serializer.is_valid():
+            serializer.save()
+            # capture the page transaction
+            page_transaction.delay(
+                new_description_html=request.data.get("description_html", "<p></p>"),
+                old_description_html=None,
+                page_id=serializer.data["id"],
+            )
+            page = self.get_queryset().get(pk=serializer.data["id"])
+            serializer = PageDetailSerializer(page)
+            return Response(serializer.data, status=status.HTTP_201_CREATED)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    def partial_update(self, request, slug, project_id, page_id):
+        try:
+            page = Page.objects.get(
+                pk=page_id,
+                workspace__slug=slug,
+                projects__id=project_id,
+                project_pages__deleted_at__isnull=True,
+            )
+
+            if page.is_locked:
+                return Response({"error": "Page is locked"}, status=status.HTTP_400_BAD_REQUEST)
+
+            parent = request.data.get("parent", None)
+            if parent:
+                _ = Page.objects.get(
+                    pk=parent,
+                    workspace__slug=slug,
+                    projects__id=project_id,
+                    project_pages__deleted_at__isnull=True,
+                )
+
+            # Only update access if the page owner is the requesting  user
+            if page.access != request.data.get("access", page.access) and page.owned_by_id != request.user.id:
+                return Response(
+                    {"error": "Access cannot be updated since this page is owned by someone else"},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+            serializer = PageDetailSerializer(page, data=request.data, partial=True)
+            page_description = page.description_html
+            if serializer.is_valid():
+                serializer.save()
+                # capture the page transaction
+                if request.data.get("description_html"):
+                    page_transaction.delay(
+                        new_description_html=request.data.get("description_html", "<p></p>"),
+                        old_description_html=page_description,
+                        page_id=page_id,
+                    )
+
+                return Response(serializer.data, status=status.HTTP_200_OK)
+            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+        except Page.DoesNotExist:
+            return Response(
+                {"error": "Access cannot be updated since this page is owned by someone else"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+    def retrieve(self, request, slug, project_id, page_id=None):
+        page = self.get_queryset().filter(pk=page_id).first()
+        project = Project.objects.get(pk=project_id)
+        track_visit = request.query_params.get("track_visit", "true").lower() == "true"
+
+        """
+        if the role is guest and guest_view_all_features is false and owned by is not
+        the requesting user then dont show the page
+        """
+
+        if (
+            ProjectMember.objects.filter(
+                workspace__slug=slug,
+                project_id=project_id,
+                member=request.user,
+                role=5,
+                is_active=True,
+            ).exists()
+            and not project.guest_view_all_features
+            and not page.owned_by == request.user
+        ):
+            return Response(
+                {"error": "You are not allowed to view this page"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        if page is None:
+            return Response({"error": "Page not found"}, status=status.HTTP_404_NOT_FOUND)
+        else:
+            issue_ids = PageLog.objects.filter(page_id=page_id, entity_name="issue").values_list(
+                "entity_identifier", flat=True
+            )
+            data = PageDetailSerializer(page).data
+            data["issue_ids"] = issue_ids
+            if track_visit:
+                recent_visited_task.delay(
+                    slug=slug,
+                    entity_name="page",
+                    entity_identifier=page_id,
+                    user_id=request.user.id,
+                    project_id=project_id,
+                )
+            return Response(data, status=status.HTTP_200_OK)
+
+    def lock(self, request, slug, project_id, page_id):
+        page = Page.objects.get(
+            pk=page_id,
+            workspace__slug=slug,
+            projects__id=project_id,
+            project_pages__deleted_at__isnull=True,
+        )
+
+        page.is_locked = True
+        page.save()
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+    def unlock(self, request, slug, project_id, page_id):
+        page = Page.objects.get(
+            pk=page_id,
+            workspace__slug=slug,
+            projects__id=project_id,
+            project_pages__deleted_at__isnull=True,
+        )
+
+        page.is_locked = False
+        page.save()
+
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+    def access(self, request, slug, project_id, page_id):
+        access = request.data.get("access", 0)
+        page = Page.objects.get(
+            pk=page_id,
+            workspace__slug=slug,
+            projects__id=project_id,
+            project_pages__deleted_at__isnull=True,
+        )
+
+        # Only update access if the page owner is the requesting user
+        if page.access != request.data.get("access", page.access) and page.owned_by_id != request.user.id:
+            return Response(
+                {"error": "Access cannot be updated since this page is owned by someone else"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        page.access = access
+        page.save()
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+    def list(self, request, slug, project_id):
+        queryset = self.get_queryset()
+        project = Project.objects.get(pk=project_id)
+        if (
+            ProjectMember.objects.filter(
+                workspace__slug=slug,
+                project_id=project_id,
+                member=request.user,
+                role=5,
+                is_active=True,
+            ).exists()
+            and not project.guest_view_all_features
+        ):
+            queryset = queryset.filter(owned_by=request.user)
+        pages = PageSerializer(queryset, many=True).data
+        return Response(pages, status=status.HTTP_200_OK)
+
+    def archive(self, request, slug, project_id, page_id):
+        page = Page.objects.get(
+            pk=page_id,
+            workspace__slug=slug,
+            projects__id=project_id,
+            project_pages__deleted_at__isnull=True,
+        )
+
+        # only the owner or admin can archive the page
+        if (
+            ProjectMember.objects.filter(
+                project_id=project_id, member=request.user, is_active=True, role__lte=15
+            ).exists()
+            and request.user.id != page.owned_by_id
+        ):
+            return Response(
+                {"error": "Only the owner or admin can archive the page"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        UserFavorite.objects.filter(
+            entity_type="page",
+            entity_identifier=page_id,
+            project_id=project_id,
+            workspace__slug=slug,
+        ).delete()
+
+        unarchive_archive_page_and_descendants(page_id, datetime.now())
+
+        return Response({"archived_at": str(datetime.now())}, status=status.HTTP_200_OK)
+
+    def unarchive(self, request, slug, project_id, page_id):
+        page = Page.objects.get(
+            pk=page_id,
+            workspace__slug=slug,
+            projects__id=project_id,
+            project_pages__deleted_at__isnull=True,
+        )
+
+        # only the owner or admin can un archive the page
+        if (
+            ProjectMember.objects.filter(
+                project_id=project_id, member=request.user, is_active=True, role__lte=15
+            ).exists()
+            and request.user.id != page.owned_by_id
+        ):
+            return Response(
+                {"error": "Only the owner or admin can un archive the page"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # if parent archived then page will be un archived breaking hierarchy
+        if page.parent_id and page.parent.archived_at:
+            page.parent = None
+            page.save(update_fields=["parent"])
+
+        unarchive_archive_page_and_descendants(page_id, None)
+
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+    def destroy(self, request, slug, project_id, page_id):
+        page = Page.objects.get(
+            pk=page_id,
+            workspace__slug=slug,
+            projects__id=project_id,
+            project_pages__deleted_at__isnull=True,
+        )
+
+        if page.archived_at is None:
+            return Response(
+                {"error": "The page should be archived before deleting"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        if page.owned_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 owner can delete the page"},
+                status=status.HTTP_403_FORBIDDEN,
+            )
+
+        # remove parent from all the children
+        _ = Page.objects.filter(
+            parent_id=page_id,
+            projects__id=project_id,
+            workspace__slug=slug,
+            project_pages__deleted_at__isnull=True,
+        ).update(parent=None)
+
+        page.delete()
+        # Delete the user favorite page
+        UserFavorite.objects.filter(
+            project=project_id,
+            workspace__slug=slug,
+            entity_identifier=page_id,
+            entity_type="page",
+        ).delete()
+        # Delete the page from recent visit
+        UserRecentVisit.objects.filter(
+            project_id=project_id,
+            workspace__slug=slug,
+            entity_identifier=page_id,
+            entity_name="page",
+        ).delete(soft=False)
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+    def summary(self, request, slug, project_id):
+        queryset = (
+            Page.objects.filter(workspace__slug=slug)
+            .filter(
+                projects__project_projectmember__member=self.request.user,
+                projects__project_projectmember__is_active=True,
+                projects__archived_at__isnull=True,
+            )
+            .filter(parent__isnull=True)
+            .filter(Q(owned_by=request.user) | Q(access=0))
+            .annotate(
+                project=Exists(
+                    ProjectPage.objects.filter(page_id=OuterRef("id"), project_id=self.kwargs.get("project_id"))
+                )
+            )
+            .filter(project=True)
+            .distinct()
+        )
+
+        project = Project.objects.get(pk=project_id)
+        if (
+            ProjectMember.objects.filter(
+                workspace__slug=slug,
+                project_id=project_id,
+                member=request.user,
+                role=ROLE.GUEST.value,
+                is_active=True,
+            ).exists()
+            and not project.guest_view_all_features
+        ):
+            queryset = queryset.filter(owned_by=request.user)
+
+        stats = queryset.aggregate(
+            public_pages=Count(
+                Case(
+                    When(access=Page.PUBLIC_ACCESS, archived_at__isnull=True, then=1),
+                    output_field=IntegerField(),
+                )
+            ),
+            private_pages=Count(
+                Case(
+                    When(access=Page.PRIVATE_ACCESS, archived_at__isnull=True, then=1),
+                    output_field=IntegerField(),
+                )
+            ),
+            archived_pages=Count(Case(When(archived_at__isnull=False, then=1), output_field=IntegerField())),
+        )
+
+        return Response(stats, status=status.HTTP_200_OK)
+
+
+class PageFavoriteViewSet(BaseViewSet):
+    model = UserFavorite
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
+    def create(self, request, slug, project_id, page_id):
+        _ = UserFavorite.objects.create(
+            project_id=project_id,
+            entity_identifier=page_id,
+            entity_type="page",
+            user=request.user,
+        )
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
+    def destroy(self, request, slug, project_id, page_id):
+        page_favorite = UserFavorite.objects.get(
+            project=project_id,
+            user=request.user,
+            workspace__slug=slug,
+            entity_identifier=page_id,
+            entity_type="page",
+        )
+        page_favorite.delete(soft=False)
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+class PagesDescriptionViewSet(BaseViewSet):
+    permission_classes = [ProjectPagePermission]
+
+    def retrieve(self, request, slug, project_id, page_id):
+        page = Page.objects.get(
+            Q(owned_by=self.request.user) | Q(access=0),
+            pk=page_id,
+            workspace__slug=slug,
+            projects__id=project_id,
+            project_pages__deleted_at__isnull=True,
+        )
+        binary_data = page.description_binary
+
+        def stream_data():
+            if binary_data:
+                yield binary_data
+            else:
+                yield b""
+
+        response = StreamingHttpResponse(stream_data(), content_type="application/octet-stream")
+        response["Content-Disposition"] = 'attachment; filename="page_description.bin"'
+        return response
+
+    def partial_update(self, request, slug, project_id, page_id):
+        page = Page.objects.get(
+            Q(owned_by=self.request.user) | Q(access=0),
+            pk=page_id,
+            workspace__slug=slug,
+            projects__id=project_id,
+            project_pages__deleted_at__isnull=True,
+        )
+
+        if page.is_locked:
+            return Response(
+                {
+                    "error_code": ERROR_CODES["PAGE_LOCKED"],
+                    "error_message": "PAGE_LOCKED",
+                },
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        if page.archived_at:
+            return Response(
+                {
+                    "error_code": ERROR_CODES["PAGE_ARCHIVED"],
+                    "error_message": "PAGE_ARCHIVED",
+                },
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # Store the old description_html before saving (needed for both tasks)
+        old_description_html = page.description_html
+
+        # Serialize the existing instance
+        existing_instance = json.dumps({"description_html": old_description_html}, cls=DjangoJSONEncoder)
+
+        # Use serializer for validation and update
+        serializer = PageBinaryUpdateSerializer(page, data=request.data, partial=True)
+        if serializer.is_valid():
+            serializer.save()
+
+            # Capture the page transaction
+            if request.data.get("description_html"):
+                page_transaction.delay(
+                    new_description_html=request.data.get("description_html", "<p></p>"),
+                    old_description_html=old_description_html,
+                    page_id=page_id,
+                )
+
+            # Run background tasks
+            track_page_version.delay(
+                page_id=page_id,
+                existing_instance=existing_instance,
+                user_id=request.user.id,
+            )
+            return Response({"message": "Updated successfully"})
+        else:
+            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+
+class PageDuplicateEndpoint(BaseAPIView):
+    permission_classes = [ProjectPagePermission]
+
+    def post(self, request, slug, project_id, page_id):
+        page = Page.objects.get(
+            pk=page_id,
+            workspace__slug=slug,
+            projects__id=project_id,
+            project_pages__deleted_at__isnull=True,
+        )
+
+        # check for permission
+        if page.access == Page.PRIVATE_ACCESS and page.owned_by_id != request.user.id:
+            return Response({"error": "Permission denied"}, status=status.HTTP_403_FORBIDDEN)
+
+        # get all the project ids where page is present
+        project_ids = ProjectPage.objects.filter(page_id=page_id).values_list("project_id", flat=True)
+
+        page.pk = None
+        page.name = f"{page.name} (Copy)"
+        page.description_binary = None
+        page.owned_by = request.user
+        page.created_by = request.user
+        page.updated_by = request.user
+        page.save()
+
+        for project_id in project_ids:
+            ProjectPage.objects.create(
+                workspace_id=page.workspace_id,
+                project_id=project_id,
+                page_id=page.id,
+                created_by_id=page.created_by_id,
+                updated_by_id=page.updated_by_id,
+            )
+
+        page_transaction.delay(
+            new_description_html=page.description_html,
+            old_description_html=None,
+            page_id=page.id,
+        )
+
+        # Copy the s3 objects uploaded in the page
+        copy_s3_objects_of_description_and_assets.delay(
+            entity_name="PAGE",
+            entity_identifier=page.id,
+            project_id=project_id,
+            slug=slug,
+            user_id=request.user.id,
+        )
+
+        page = (
+            Page.objects.filter(pk=page.id)
+            .annotate(
+                project_ids=Coalesce(
+                    ArrayAgg("projects__id", distinct=True, filter=~Q(projects__id=True)),
+                    Value([], output_field=ArrayField(UUIDField())),
+                )
+            )
+            .first()
+        )
+        serializer = PageDetailSerializer(page)
+        return Response(serializer.data, status=status.HTTP_201_CREATED)

plane-src/apps/api/plane/app/views/page/version.py

@@ -0,0 +1,31 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+# Third party imports
+from rest_framework import status
+from rest_framework.response import Response
+
+# Module imports
+from plane.db.models import PageVersion
+from ..base import BaseAPIView
+from plane.app.serializers import PageVersionSerializer, PageVersionDetailSerializer
+from plane.app.permissions import ProjectPagePermission
+
+
+class PageVersionEndpoint(BaseAPIView):
+    permission_classes = [ProjectPagePermission]
+
+    def get(self, request, slug, project_id, page_id, pk=None):
+        # Check if pk is provided
+        if pk:
+            # Return a single page version
+            page_version = PageVersion.objects.get(workspace__slug=slug, page_id=page_id, pk=pk)
+            # Serialize the page version
+            serializer = PageVersionDetailSerializer(page_version)
+            return Response(serializer.data, status=status.HTTP_200_OK)
+        # Return all page versions
+        page_versions = PageVersion.objects.filter(workspace__slug=slug, page_id=page_id)
+        # Serialize the page versions
+        serializer = PageVersionSerializer(page_versions, many=True)
+        return Response(serializer.data, status=status.HTTP_200_OK)

plane-src/apps/api/plane/app/views/project/base.py

@@ -0,0 +1,571 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+# Python imports
+import json
+
+
+# Django imports
+from django.core.serializers.json import DjangoJSONEncoder
+from django.db.models import Exists, F, OuterRef, Prefetch, Q, Subquery, Count
+from django.utils import timezone
+
+# Third Party imports
+from rest_framework import status
+from rest_framework.response import Response
+
+# Module imports
+from plane.app.permissions import ROLE, ProjectMemberPermission, allow_permission
+from plane.app.serializers import (
+    DeployBoardSerializer,
+    ProjectListSerializer,
+    ProjectSerializer,
+)
+from plane.app.views.base import BaseAPIView, BaseViewSet
+from plane.bgtasks.recent_visited_task import recent_visited_task
+from plane.bgtasks.webhook_task import model_activity, webhook_activity
+from plane.db.models import (
+    UserFavorite,
+    DeployBoard,
+    Intake,
+    Project,
+    ProjectIdentifier,
+    ProjectMember,
+    ProjectNetwork,
+    ProjectUserProperty,
+    State,
+    DEFAULT_STATES,
+    Workspace,
+    WorkspaceMember,
+)
+from plane.db.models.intake import IntakeIssueStatus
+from plane.utils.host import base_host
+
+
+class ProjectViewSet(BaseViewSet):
+    serializer_class = ProjectListSerializer
+    model = Project
+    webhook_event = "project"
+    use_read_replica = True
+
+    def get_queryset(self):
+        sort_order = ProjectUserProperty.objects.filter(
+            user=self.request.user,
+            project_id=OuterRef("pk"),
+            workspace__slug=self.kwargs.get("slug"),
+        ).values("sort_order")
+        return self.filter_queryset(
+            super()
+            .get_queryset()
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .select_related("workspace", "workspace__owner", "default_assignee", "project_lead")
+            .annotate(
+                is_favorite=Exists(
+                    UserFavorite.objects.filter(
+                        user=self.request.user,
+                        entity_identifier=OuterRef("pk"),
+                        entity_type="project",
+                        project_id=OuterRef("pk"),
+                    )
+                )
+            )
+            .annotate(
+                member_role=ProjectMember.objects.filter(
+                    project_id=OuterRef("pk"),
+                    member_id=self.request.user.id,
+                    is_active=True,
+                ).values("role")
+            )
+            .annotate(
+                anchor=DeployBoard.objects.filter(
+                    entity_name="project",
+                    entity_identifier=OuterRef("pk"),
+                    workspace__slug=self.kwargs.get("slug"),
+                ).values("anchor")
+            )
+            .annotate(sort_order=Subquery(sort_order))
+            .prefetch_related(
+                Prefetch(
+                    "project_projectmember",
+                    queryset=ProjectMember.objects.filter(
+                        workspace__slug=self.kwargs.get("slug"), is_active=True
+                    ).select_related("member"),
+                    to_attr="members_list",
+                )
+            )
+            .distinct()
+        )
+
+    @allow_permission(allowed_roles=[ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], level="WORKSPACE")
+    def list_detail(self, request, slug):
+        fields = [field for field in request.GET.get("fields", "").split(",") if field]
+        projects = self.get_queryset().order_by("sort_order", "name")
+        if WorkspaceMember.objects.filter(
+            member=request.user,
+            workspace__slug=slug,
+            is_active=True,
+            role=ROLE.GUEST.value,
+        ).exists():
+            projects = projects.filter(
+                project_projectmember__member=self.request.user,
+                project_projectmember__is_active=True,
+            )
+
+        if WorkspaceMember.objects.filter(
+            member=request.user,
+            workspace__slug=slug,
+            is_active=True,
+            role=ROLE.MEMBER.value,
+        ).exists():
+            projects = projects.filter(
+                Q(
+                    project_projectmember__member=self.request.user,
+                    project_projectmember__is_active=True,
+                )
+                | Q(network=2)
+            )
+
+        if request.GET.get("per_page", False) and request.GET.get("cursor", False):
+            return self.paginate(
+                order_by=request.GET.get("order_by", "-created_at"),
+                request=request,
+                queryset=(projects),
+                on_results=lambda projects: ProjectListSerializer(projects, many=True).data,
+            )
+
+        projects = ProjectListSerializer(projects, many=True, fields=fields if fields else None).data
+        return Response(projects, status=status.HTTP_200_OK)
+
+    @allow_permission(allowed_roles=[ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], level="WORKSPACE")
+    def list(self, request, slug):
+        sort_order = ProjectUserProperty.objects.filter(
+            user=self.request.user,
+            project_id=OuterRef("pk"),
+            workspace__slug=self.kwargs.get("slug"),
+        ).values("sort_order")
+
+        projects = (
+            Project.objects.filter(workspace__slug=self.kwargs.get("slug"))
+            .select_related("workspace", "workspace__owner", "default_assignee", "project_lead")
+            .annotate(
+                member_role=ProjectMember.objects.filter(
+                    project_id=OuterRef("pk"),
+                    member_id=self.request.user.id,
+                    is_active=True,
+                ).values("role")
+            )
+            .annotate(
+                intake_count=Count(
+                    "project_intakeissue",
+                    filter=Q(
+                        project_intakeissue__status=IntakeIssueStatus.PENDING.value,
+                        project_intakeissue__deleted_at__isnull=True,
+                    ),
+                )
+            )
+            .annotate(inbox_view=F("intake_view"))
+            .annotate(sort_order=Subquery(sort_order))
+            .distinct()
+        ).values(
+            "id",
+            "name",
+            "identifier",
+            "sort_order",
+            "logo_props",
+            "member_role",
+            "intake_count",
+            "archived_at",
+            "workspace",
+            "cycle_view",
+            "issue_views_view",
+            "module_view",
+            "page_view",
+            "inbox_view",
+            "guest_view_all_features",
+            "project_lead",
+            "network",
+            "created_at",
+            "updated_at",
+            "created_by",
+            "updated_by",
+        )
+
+        if WorkspaceMember.objects.filter(
+            member=request.user,
+            workspace__slug=slug,
+            is_active=True,
+            role=ROLE.GUEST.value,
+        ).exists():
+            projects = projects.filter(
+                project_projectmember__member=self.request.user,
+                project_projectmember__is_active=True,
+            )
+
+        if WorkspaceMember.objects.filter(
+            member=request.user,
+            workspace__slug=slug,
+            is_active=True,
+            role=ROLE.MEMBER.value,
+        ).exists():
+            projects = projects.filter(
+                Q(
+                    project_projectmember__member=self.request.user,
+                    project_projectmember__is_active=True,
+                )
+                | Q(network=2)
+            )
+        return Response(projects, status=status.HTTP_200_OK)
+
+    @allow_permission(allowed_roles=[ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], level="WORKSPACE")
+    def retrieve(self, request, slug, pk):
+        project = self.get_queryset().filter(archived_at__isnull=True).filter(pk=pk).first()
+
+        if project is None:
+            return Response({"error": "Project does not exist"}, status=status.HTTP_404_NOT_FOUND)
+
+        member_ids = [str(project_member.member_id) for project_member in project.members_list]
+
+        if str(request.user.id) not in member_ids:
+            if project.network == ProjectNetwork.SECRET.value:
+                return Response(
+                    {"error": "You do not have permission"},
+                    status=status.HTTP_403_FORBIDDEN,
+                )
+            else:
+                return Response(
+                    {"error": "You are not a member of this project"},
+                    status=status.HTTP_409_CONFLICT,
+                )
+
+        recent_visited_task.delay(
+            slug=slug,
+            project_id=pk,
+            entity_name="project",
+            entity_identifier=pk,
+            user_id=request.user.id,
+        )
+
+        serializer = ProjectListSerializer(project)
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER], level="WORKSPACE")
+    def create(self, request, slug):
+        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=ROLE.ADMIN.value,
+            )
+
+            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=ROLE.ADMIN.value,
+                )
+
+            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 DEFAULT_STATES
+                ]
+            )
+
+            project = self.get_queryset().filter(pk=serializer.data["id"]).first()
+
+            # Create the 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 = ProjectListSerializer(project)
+            return Response(serializer.data, status=status.HTTP_201_CREATED)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    def partial_update(self, request, slug, pk=None):
+        # try:
+        is_workspace_admin = WorkspaceMember.objects.filter(
+            member=request.user,
+            workspace__slug=slug,
+            is_active=True,
+            role=ROLE.ADMIN.value,
+        ).exists()
+
+        is_project_admin = ProjectMember.objects.filter(
+            member=request.user,
+            workspace__slug=slug,
+            project_id=pk,
+            role=ROLE.ADMIN.value,
+            is_active=True,
+        ).exists()
+
+        # Return error for if the user is neither workspace admin nor project admin
+        if not is_project_admin and not is_workspace_admin:
+            return Response(
+                {"error": "You don't have the required permissions."},
+                status=status.HTTP_403_FORBIDDEN,
+            )
+
+        workspace = Workspace.objects.get(slug=slug)
+
+        project = Project.objects.get(pk=pk)
+        intake_view = request.data.get("inbox_view", project.intake_view)
+        current_instance = json.dumps(ProjectSerializer(project).data, cls=DjangoJSONEncoder)
+        if project.archived_at:
+            return Response(
+                {"error": "Archived projects 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 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 = ProjectListSerializer(project)
+            return Response(serializer.data, status=status.HTTP_200_OK)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    def destroy(self, request, slug, pk):
+        if (
+            WorkspaceMember.objects.filter(
+                member=request.user,
+                workspace__slug=slug,
+                is_active=True,
+                role=ROLE.ADMIN.value,
+            ).exists()
+            or ProjectMember.objects.filter(
+                member=request.user,
+                workspace__slug=slug,
+                project_id=pk,
+                role=ROLE.ADMIN.value,
+                is_active=True,
+            ).exists()
+        ):
+            project = Project.objects.get(pk=pk, workspace__slug=slug)
+            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,
+            )
+            # Delete the project members
+            DeployBoard.objects.filter(project_id=pk, workspace__slug=slug).delete()
+
+            # Delete the user favorite
+            UserFavorite.objects.filter(project_id=pk, workspace__slug=slug).delete()
+
+            return Response(status=status.HTTP_204_NO_CONTENT)
+        else:
+            return Response(
+                {"error": "You don't have the required permissions."},
+                status=status.HTTP_403_FORBIDDEN,
+            )
+
+
+class ProjectArchiveUnarchiveEndpoint(BaseAPIView):
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
+    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({"archived_at": str(project.archived_at)}, status=status.HTTP_200_OK)
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
+    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)
+
+
+class ProjectIdentifierEndpoint(BaseAPIView):
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER], level="WORKSPACE")
+    def get(self, request, slug):
+        name = request.GET.get("name", "").strip().upper()
+
+        if name == "":
+            return Response({"error": "Name is required"}, status=status.HTTP_400_BAD_REQUEST)
+
+        exists = ProjectIdentifier.objects.filter(name=name, workspace__slug=slug).values("id", "name", "project")
+
+        return Response({"exists": len(exists), "identifiers": exists}, status=status.HTTP_200_OK)
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER], level="WORKSPACE")
+    def delete(self, request, slug):
+        name = request.data.get("name", "").strip().upper()
+
+        if name == "":
+            return Response({"error": "Name is required"}, status=status.HTTP_400_BAD_REQUEST)
+
+        if Project.objects.filter(identifier=name, workspace__slug=slug).exists():
+            return Response(
+                {"error": "Cannot delete an identifier of an existing project"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        ProjectIdentifier.objects.filter(name=name, workspace__slug=slug).delete()
+
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+class ProjectUserViewsEndpoint(BaseAPIView):
+    def post(self, request, slug, project_id):
+        project = Project.objects.get(pk=project_id, workspace__slug=slug)
+
+        project_member = ProjectMember.objects.filter(member=request.user, project=project, is_active=True).first()
+
+        if project_member is None:
+            return Response({"error": "Forbidden"}, status=status.HTTP_403_FORBIDDEN)
+
+        view_props = project_member.view_props
+        default_props = project_member.default_props
+        preferences = project_member.preferences
+        sort_order = project_member.sort_order
+
+        project_member.view_props = request.data.get("view_props", view_props)
+        project_member.default_props = request.data.get("default_props", default_props)
+        project_member.preferences = request.data.get("preferences", preferences)
+        project_member.sort_order = request.data.get("sort_order", sort_order)
+
+        project_member.save()
+
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+class ProjectFavoritesViewSet(BaseViewSet):
+    model = UserFavorite
+
+    def get_queryset(self):
+        return self.filter_queryset(
+            super()
+            .get_queryset()
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .filter(user=self.request.user)
+            .select_related("project", "project__project_lead", "project__default_assignee")
+            .select_related("workspace", "workspace__owner")
+        )
+
+    def perform_create(self, serializer):
+        serializer.save(user=self.request.user)
+
+    def create(self, request, slug):
+        _ = UserFavorite.objects.create(
+            user=request.user,
+            entity_type="project",
+            entity_identifier=request.data.get("project"),
+            project_id=request.data.get("project"),
+        )
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+    def destroy(self, request, slug, project_id):
+        project_favorite = UserFavorite.objects.get(
+            entity_identifier=project_id,
+            entity_type="project",
+            project=project_id,
+            user=request.user,
+            workspace__slug=slug,
+        )
+        project_favorite.delete(soft=False)
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+class DeployBoardViewSet(BaseViewSet):
+    permission_classes = [ProjectMemberPermission]
+    serializer_class = DeployBoardSerializer
+    model = DeployBoard
+
+    def list(self, request, slug, project_id):
+        project_deploy_board = DeployBoard.objects.filter(
+            entity_name="project", entity_identifier=project_id, workspace__slug=slug
+        ).first()
+
+        serializer = DeployBoardSerializer(project_deploy_board)
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+    def create(self, request, slug, project_id):
+        comments = request.data.get("is_comments_enabled", False)
+        reactions = request.data.get("is_reactions_enabled", False)
+        intake = request.data.get("intake", None)
+        votes = request.data.get("is_votes_enabled", False)
+        views = request.data.get(
+            "views",
+            {
+                "list": True,
+                "kanban": True,
+                "calendar": True,
+                "gantt": True,
+                "spreadsheet": True,
+            },
+        )
+
+        project_deploy_board, _ = DeployBoard.objects.get_or_create(
+            entity_name="project", entity_identifier=project_id, project_id=project_id
+        )
+        project_deploy_board.intake = intake
+        project_deploy_board.view_props = views
+        project_deploy_board.is_votes_enabled = votes
+        project_deploy_board.is_comments_enabled = comments
+        project_deploy_board.is_reactions_enabled = reactions
+
+        project_deploy_board.save()
+
+        serializer = DeployBoardSerializer(project_deploy_board)
+        return Response(serializer.data, status=status.HTTP_200_OK)

plane-src/apps/api/plane/app/views/project/invite.py

@@ -0,0 +1,254 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+# Python imports
+import jwt
+from datetime import datetime
+
+# Django imports
+from django.core.exceptions import ValidationError
+from django.core.validators import validate_email
+from django.conf import settings
+from django.utils import timezone
+
+# Third Party imports
+from rest_framework.response import Response
+from rest_framework import status
+from rest_framework.permissions import AllowAny
+
+# Module imports
+from .base import BaseViewSet, BaseAPIView
+from plane.app.serializers import ProjectMemberInviteSerializer
+from plane.app.permissions import allow_permission, ROLE
+from plane.db.models import (
+    ProjectMember,
+    Workspace,
+    ProjectMemberInvite,
+    User,
+    WorkspaceMember,
+    Project,
+    ProjectUserProperty,
+)
+from plane.db.models.project import ProjectNetwork
+from plane.utils.host import base_host
+
+
+class ProjectInvitationsViewset(BaseViewSet):
+    serializer_class = ProjectMemberInviteSerializer
+    model = ProjectMemberInvite
+
+    search_fields = []
+
+    def get_queryset(self):
+        return self.filter_queryset(
+            super()
+            .get_queryset()
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .filter(project_id=self.kwargs.get("project_id"))
+            .select_related("project")
+            .select_related("workspace", "workspace__owner")
+        )
+
+    @allow_permission([ROLE.ADMIN])
+    def create(self, request, slug, project_id):
+        emails = request.data.get("emails", [])
+
+        # Check if email is provided
+        if not emails:
+            return Response({"error": "Emails are required"}, status=status.HTTP_400_BAD_REQUEST)
+
+        for email in emails:
+            workspace_role = WorkspaceMember.objects.filter(
+                workspace__slug=slug, member__email=email.get("email"), is_active=True
+            ).role
+
+            if workspace_role in [5, 20] and workspace_role != email.get("role", 5):
+                return Response({"error": "You cannot invite a user with different role than workspace role"})
+
+        workspace = Workspace.objects.get(slug=slug)
+
+        project_invitations = []
+        for email in emails:
+            try:
+                validate_email(email.get("email"))
+                project_invitations.append(
+                    ProjectMemberInvite(
+                        email=email.get("email").strip().lower(),
+                        project_id=project_id,
+                        workspace_id=workspace.id,
+                        token=jwt.encode(
+                            {"email": email, "timestamp": datetime.now().timestamp()},
+                            settings.SECRET_KEY,
+                            algorithm="HS256",
+                        ),
+                        role=email.get("role", 5),
+                        created_by=request.user,
+                    )
+                )
+            except ValidationError:
+                return Response(
+                    {
+                        "error": f"Invalid email - {email} provided a valid email address is required to send the invite"  # noqa: E501
+                    },
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+        # Create workspace member invite
+        project_invitations = ProjectMemberInvite.objects.bulk_create(
+            project_invitations, batch_size=10, ignore_conflicts=True
+        )
+        current_site = base_host(request=request, is_app=True)
+
+        # Send invitations
+        for invitation in project_invitations:
+            project_invitations.delay(
+                invitation.email,
+                project_id,
+                invitation.token,
+                current_site,
+                request.user.email,
+            )
+
+        return Response({"message": "Email sent successfully"}, status=status.HTTP_200_OK)
+
+
+class UserProjectInvitationsViewset(BaseViewSet):
+    serializer_class = ProjectMemberInviteSerializer
+    model = ProjectMemberInvite
+
+    def get_queryset(self):
+        return self.filter_queryset(
+            super()
+            .get_queryset()
+            .filter(email=self.request.user.email)
+            .select_related("workspace", "workspace__owner", "project")
+        )
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER], level="WORKSPACE")
+    def create(self, request, slug):
+        project_ids = request.data.get("project_ids", [])
+
+        # Get the workspace user role
+        workspace_member = WorkspaceMember.objects.get(member=request.user, workspace__slug=slug, is_active=True)
+
+        # Get all the projects
+        projects = Project.objects.filter(id__in=project_ids, workspace__slug=slug).only("id", "network")
+        # Check if user has permission to join each project
+        for project in projects:
+            if project.network == ProjectNetwork.SECRET.value and workspace_member.role != ROLE.ADMIN.value:
+                return Response(
+                    {"error": "Only workspace admins can join private project"},
+                    status=status.HTTP_403_FORBIDDEN,
+                )
+
+        workspace_role = workspace_member.role
+        workspace = workspace_member.workspace
+
+        # If the user was already part of workspace
+        _ = ProjectMember.objects.filter(workspace__slug=slug, project_id__in=project_ids, member=request.user).update(
+            is_active=True
+        )
+
+        ProjectMember.objects.bulk_create(
+            [
+                ProjectMember(
+                    project_id=project_id,
+                    member=request.user,
+                    role=workspace_role,
+                    workspace=workspace,
+                    created_by=request.user,
+                )
+                for project_id in project_ids
+            ],
+            ignore_conflicts=True,
+        )
+
+        ProjectUserProperty.objects.bulk_create(
+            [
+                ProjectUserProperty(
+                    project_id=project_id,
+                    user=request.user,
+                    workspace=workspace,
+                    created_by=request.user,
+                )
+                for project_id in project_ids
+            ],
+            ignore_conflicts=True,
+        )
+
+        return Response({"message": "Projects joined successfully"}, status=status.HTTP_201_CREATED)
+
+
+class ProjectJoinEndpoint(BaseAPIView):
+    permission_classes = [AllowAny]
+
+    def post(self, request, slug, project_id, pk):
+        project_invite = ProjectMemberInvite.objects.get(pk=pk, project_id=project_id, workspace__slug=slug)
+
+        email = request.data.get("email", "")
+
+        if email == "" or project_invite.email != email:
+            return Response(
+                {"error": "You do not have permission to join the project"},
+                status=status.HTTP_403_FORBIDDEN,
+            )
+
+        if project_invite.responded_at is None:
+            project_invite.accepted = request.data.get("accepted", False)
+            project_invite.responded_at = timezone.now()
+            project_invite.save()
+
+            if project_invite.accepted:
+                # Check if the user account exists
+                user = User.objects.filter(email=email).first()
+
+                # Check if user is a part of workspace
+                workspace_member = WorkspaceMember.objects.filter(workspace__slug=slug, member=user).first()
+                # Add him to workspace
+                if workspace_member is None:
+                    _ = WorkspaceMember.objects.create(
+                        workspace_id=project_invite.workspace_id,
+                        member=user,
+                        role=(15 if project_invite.role >= 15 else project_invite.role),
+                    )
+                else:
+                    # Else make him active
+                    workspace_member.is_active = True
+                    workspace_member.save()
+
+                # Check if the user was already a member of project then activate the user
+                project_member = ProjectMember.objects.filter(
+                    workspace_id=project_invite.workspace_id, member=user
+                ).first()
+                if project_member is None:
+                    # Create a Project Member
+                    _ = ProjectMember.objects.create(
+                        project_id=project_id,
+                        member=user,
+                        role=project_invite.role,
+                    )
+                else:
+                    project_member.is_active = True
+                    project_member.role = project_member.role
+                    project_member.save()
+
+                return Response(
+                    {"message": "Project Invitation Accepted"},
+                    status=status.HTTP_200_OK,
+                )
+
+            return Response(
+                {"message": "Project Invitation was not accepted"},
+                status=status.HTTP_200_OK,
+            )
+
+        return Response(
+            {"error": "You have already responded to the invitation request"},
+            status=status.HTTP_400_BAD_REQUEST,
+        )
+
+    def get(self, request, slug, project_id, pk):
+        project_invitation = ProjectMemberInvite.objects.get(workspace__slug=slug, project_id=project_id, pk=pk)
+        serializer = ProjectMemberInviteSerializer(project_invitation)
+        return Response(serializer.data, status=status.HTTP_200_OK)

plane-src/apps/api/plane/app/views/project/member.py

@@ -0,0 +1,385 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+# Third Party imports
+from rest_framework.response import Response
+from rest_framework import status
+from django.db.models import Min
+
+# Module imports
+from .base import BaseViewSet, BaseAPIView
+from plane.app.serializers import (
+    ProjectMemberSerializer,
+    ProjectMemberAdminSerializer,
+    ProjectMemberRoleSerializer,
+    ProjectMemberPreferenceSerializer,
+)
+
+from plane.app.permissions import WorkspaceUserPermission
+
+from plane.db.models import Project, ProjectMember, ProjectUserProperty, WorkspaceMember
+from plane.bgtasks.project_add_user_email_task import project_add_user_email
+from plane.utils.host import base_host
+from plane.app.permissions.base import allow_permission, ROLE
+
+
+class ProjectMemberViewSet(BaseViewSet):
+    serializer_class = ProjectMemberAdminSerializer
+    model = ProjectMember
+
+    search_fields = ["member__display_name", "member__first_name"]
+
+    def get_queryset(self):
+        return self.filter_queryset(
+            super()
+            .get_queryset()
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .filter(project_id=self.kwargs.get("project_id"))
+            .filter(member__is_bot=False)
+            .filter()
+            .select_related("project")
+            .select_related("member")
+            .select_related("workspace", "workspace__owner")
+        )
+
+    @allow_permission([ROLE.ADMIN])
+    def create(self, request, slug, project_id):
+        # Get the list of members to be added to the project and their roles i.e. the user_id and the role
+        members = request.data.get("members", [])
+
+        # get the project
+        project = Project.objects.get(pk=project_id, workspace__slug=slug)
+
+        # Check if the members array is empty
+        if not len(members):
+            return Response(
+                {"error": "At least one member is required"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # Initialize the bulk arrays
+        bulk_project_members = []
+        bulk_issue_props = []
+
+        # Create a dictionary of the member_id and their roles
+        member_roles = {member.get("member_id"): member.get("role") for member in members}
+
+        # check the workspace role of the new user
+        for member in member_roles:
+            workspace_member_role = WorkspaceMember.objects.get(
+                workspace__slug=slug, member=member, is_active=True
+            ).role
+            if workspace_member_role in [20] and member_roles.get(member) in [5, 15]:
+                return Response(
+                    {"error": "You cannot add a user with role lower than the workspace role"},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+            if workspace_member_role in [5] and member_roles.get(member) in [15, 20]:
+                return Response(
+                    {"error": "You cannot add a user with role higher than the workspace role"},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+        # Update roles in the members array based on the member_roles dictionary and set is_active to True
+        for project_member in ProjectMember.objects.filter(
+            project_id=project_id,
+            member_id__in=[member.get("member_id") for member in members],
+        ):
+            project_member.role = member_roles[str(project_member.member_id)]
+            project_member.is_active = True
+            bulk_project_members.append(project_member)
+
+        # Update the roles of the existing members
+        ProjectMember.objects.bulk_update(bulk_project_members, ["is_active", "role"], batch_size=100)
+
+        # Get the minimum sort_order for each member in the workspace
+        member_sort_orders = (
+            ProjectUserProperty.objects.filter(
+                workspace__slug=slug,
+                user_id__in=[member.get("member_id") for member in members],
+            )
+            .values("user_id")
+            .annotate(min_sort_order=Min("sort_order"))
+        )
+        # Convert to dictionary for easy lookup: {user_id: min_sort_order}
+        sort_order_map = {str(item["user_id"]): item["min_sort_order"] for item in member_sort_orders}
+
+        # Loop through requested members
+        for member in members:
+            member_id = str(member.get("member_id"))
+            # Get the minimum sort_order for this member, or use default
+            min_sort_order = sort_order_map.get(member_id)
+            # Create a new project member
+            bulk_project_members.append(
+                ProjectMember(
+                    member_id=member.get("member_id"),
+                    role=member.get("role", 5),
+                    project_id=project_id,
+                    workspace_id=project.workspace_id,
+                )
+            )
+            # Create a new issue property
+            bulk_issue_props.append(
+                ProjectUserProperty(
+                    user_id=member.get("member_id"),
+                    project_id=project_id,
+                    workspace_id=project.workspace_id,
+                    sort_order=(min_sort_order - 10000 if min_sort_order is not None else 65535),
+                )
+            )
+
+        # Bulk create the project members and issue properties
+        project_members = ProjectMember.objects.bulk_create(bulk_project_members, batch_size=10, ignore_conflicts=True)
+
+        _ = ProjectUserProperty.objects.bulk_create(bulk_issue_props, batch_size=10, ignore_conflicts=True)
+
+        project_members = ProjectMember.objects.filter(
+            project_id=project_id,
+            member_id__in=[member.get("member_id") for member in members],
+        )
+        # Send emails to notify the users
+        [
+            project_add_user_email.delay(
+                base_host(request=request, is_app=True),
+                project_member.id,
+                request.user.id,
+            )
+            for project_member in project_members
+        ]
+        # Serialize the project members
+        serializer = ProjectMemberRoleSerializer(project_members, many=True)
+        # Return the serialized data
+        return Response(serializer.data, status=status.HTTP_201_CREATED)
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
+    def list(self, request, slug, project_id):
+        # Get the list of project members for the project
+        project_members = ProjectMember.objects.filter(
+            project_id=project_id,
+            workspace__slug=slug,
+            member__is_bot=False,
+            is_active=True,
+            member__member_workspace__workspace__slug=slug,
+            member__member_workspace__is_active=True,
+        ).select_related("project", "member", "workspace")
+
+        serializer = ProjectMemberRoleSerializer(project_members, fields=("id", "member", "role"), many=True)
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
+    def retrieve(self, request, slug, project_id, pk):
+        requesting_project_member = ProjectMember.objects.get(
+            project_id=project_id,
+            workspace__slug=slug,
+            member=request.user,
+            is_active=True,
+        )
+
+        project_member = (
+            ProjectMember.objects.filter(
+                pk=pk,
+                project_id=project_id,
+                workspace__slug=slug,
+                member__is_bot=False,
+                is_active=True,
+            )
+            .select_related("project", "member", "workspace")
+            .first()
+        )
+
+        if not project_member:
+            return Response(
+                {"error": "Project member not found"},
+                status=status.HTTP_404_NOT_FOUND,
+            )
+
+        if requesting_project_member.role > ROLE.GUEST.value:
+            serializer = ProjectMemberAdminSerializer(project_member)
+        else:
+            serializer = ProjectMemberRoleSerializer(project_member, fields=("id", "member", "role"))
+
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
+    def partial_update(self, request, slug, project_id, pk):
+        project_member = ProjectMember.objects.get(pk=pk, workspace__slug=slug, project_id=project_id, is_active=True)
+
+        # Fetch the workspace role of the project member
+        workspace_role = WorkspaceMember.objects.get(
+            workspace__slug=slug, member=project_member.member, is_active=True
+        ).role
+        is_workspace_admin = workspace_role == ROLE.ADMIN.value
+
+        # Check if the user is not editing their own role if they are not an admin
+        if request.user.id == project_member.member_id and not is_workspace_admin:
+            return Response(
+                {"error": "You cannot update your own role"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+        # Check while updating user roles
+        requested_project_member = ProjectMember.objects.get(
+            project_id=project_id,
+            workspace__slug=slug,
+            member=request.user,
+            is_active=True,
+        )
+
+        if "role" in request.data:
+            # Only Admins can modify roles
+            if requested_project_member.role < ROLE.ADMIN.value and not is_workspace_admin:
+                return Response(
+                    {"error": "You do not have permission to update roles"},
+                    status=status.HTTP_403_FORBIDDEN,
+                )
+
+            # Cannot modify a member whose role is equal to or higher than your own
+            if project_member.role >= requested_project_member.role and not is_workspace_admin:
+                return Response(
+                    {"error": "You cannot update the role of a member with a role equal to or higher than your own"},
+                    status=status.HTTP_403_FORBIDDEN,
+                )
+
+            new_role = int(request.data.get("role"))
+
+            # Cannot assign a role equal to or higher than your own
+            if new_role >= requested_project_member.role and not is_workspace_admin:
+                return Response(
+                    {"error": "You cannot assign a role equal to or higher than your own"},
+                    status=status.HTTP_403_FORBIDDEN,
+                )
+
+            # Cannot assign a role higher than the target's workspace role
+            if workspace_role in [5] and new_role in [15, 20]:
+                return Response(
+                    {"error": "You cannot add a user with role higher than the workspace role"},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+        serializer = ProjectMemberSerializer(project_member, data=request.data, partial=True)
+
+        if serializer.is_valid():
+            serializer.save()
+            return Response(serializer.data, status=status.HTTP_200_OK)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    @allow_permission([ROLE.ADMIN])
+    def destroy(self, request, slug, project_id, pk):
+        project_member = ProjectMember.objects.get(
+            workspace__slug=slug,
+            project_id=project_id,
+            pk=pk,
+            member__is_bot=False,
+            is_active=True,
+        )
+        # check requesting user role
+        requesting_project_member = ProjectMember.objects.get(
+            workspace__slug=slug,
+            member=request.user,
+            project_id=project_id,
+            is_active=True,
+        )
+        # User cannot remove himself
+        if str(project_member.id) == str(requesting_project_member.id):
+            return Response(
+                {"error": "You cannot remove yourself from the workspace. Please use leave workspace"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+        # User cannot deactivate higher role
+        if requesting_project_member.role < project_member.role:
+            return Response(
+                {"error": "You cannot remove a user having role higher than you"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        project_member.is_active = False
+        project_member.save()
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
+    def leave(self, request, slug, project_id):
+        project_member = ProjectMember.objects.get(
+            workspace__slug=slug,
+            project_id=project_id,
+            member=request.user,
+            is_active=True,
+        )
+
+        # Check if the leaving user is the only admin of the project
+        if (
+            project_member.role == 20
+            and not ProjectMember.objects.filter(
+                workspace__slug=slug, project_id=project_id, role=20, is_active=True
+            ).count()
+            > 1
+        ):
+            return Response(
+                {
+                    "error": "You cannot leave the project as your the only admin of the project you will have to either delete the project or create an another admin"  # noqa: E501
+                },
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+        # Deactivate the user
+        project_member.is_active = False
+        project_member.save()
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+class ProjectMemberUserEndpoint(BaseAPIView):
+    def get(self, request, slug, project_id):
+        project_member = ProjectMember.objects.get(
+            project_id=project_id,
+            workspace__slug=slug,
+            member=request.user,
+            is_active=True,
+        )
+        serializer = ProjectMemberSerializer(project_member)
+
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+
+class UserProjectRolesEndpoint(BaseAPIView):
+    permission_classes = [WorkspaceUserPermission]
+    use_read_replica = True
+
+    def get(self, request, slug):
+        project_members = ProjectMember.objects.filter(
+            workspace__slug=slug,
+            member_id=request.user.id,
+            is_active=True,
+            member__member_workspace__workspace__slug=slug,
+            member__member_workspace__is_active=True,
+        ).values("project_id", "role")
+
+        project_members = {str(member["project_id"]): member["role"] for member in project_members}
+        return Response(project_members, status=status.HTTP_200_OK)
+
+
+class ProjectMemberPreferenceEndpoint(BaseAPIView):
+    def get_queryset(self, slug, project_id, member_id):
+        return ProjectMember.objects.get(
+            project_id=project_id,
+            member_id=member_id,
+            workspace__slug=slug,
+        )
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
+    def patch(self, request, slug, project_id, member_id):
+        project_member = self.get_queryset(slug, project_id, member_id)
+
+        serializer = ProjectMemberPreferenceSerializer(project_member, {"preferences": request.data}, partial=True)
+
+        if serializer.is_valid():
+            serializer.save()
+
+            return Response({"preferences": serializer.data["preferences"]}, status=status.HTTP_200_OK)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
+    def get(self, request, slug, project_id, member_id):
+        project_member = self.get_queryset(slug, project_id, member_id)
+
+        serializer = ProjectMemberPreferenceSerializer(project_member)
+
+        return Response(serializer.data, status=status.HTTP_200_OK)

plane-src/apps/api/plane/app/views/search/base.py

@@ -0,0 +1,727 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+# Python imports
+import re
+
+# Django imports
+from django.db import models
+from django.db.models import (
+    Q,
+    OuterRef,
+    Subquery,
+    Value,
+    UUIDField,
+    CharField,
+    When,
+    Case,
+)
+from django.contrib.postgres.aggregates import ArrayAgg
+from django.contrib.postgres.fields import ArrayField
+from django.db.models.functions import Coalesce, Concat
+from django.utils import timezone
+
+# Third party imports
+from rest_framework import status
+from rest_framework.response import Response
+
+# Module imports
+from plane.app.views.base import BaseAPIView
+from plane.db.models import (
+    Workspace,
+    Project,
+    Issue,
+    Cycle,
+    Module,
+    Page,
+    IssueView,
+    ProjectMember,
+    ProjectPage,
+    WorkspaceMember,
+)
+
+
+class GlobalSearchEndpoint(BaseAPIView):
+    """Endpoint to search across multiple fields in the workspace and
+    also show related workspace if found
+    """
+
+    def filter_workspaces(self, query, _slug, _project_id, _workspace_search):
+        fields = ["name"]
+        q = Q()
+        if query:
+            for field in fields:
+                q |= Q(**{f"{field}__icontains": query})
+        return (
+            Workspace.objects.filter(q, workspace_member__member=self.request.user)
+            .order_by("-created_at")
+            .distinct()
+            .values("name", "id", "slug")
+        )
+
+    def filter_projects(self, query, slug, _project_id, _workspace_search):
+        fields = ["name", "identifier"]
+        q = Q()
+        if query:
+            for field in fields:
+                q |= Q(**{f"{field}__icontains": query})
+        return (
+            Project.objects.filter(
+                q,
+                project_projectmember__member=self.request.user,
+                project_projectmember__is_active=True,
+                archived_at__isnull=True,
+                workspace__slug=slug,
+            )
+            .order_by("-created_at")
+            .distinct()
+            .values("name", "id", "identifier", "workspace__slug")
+        )
+
+    def filter_issues(self, query, slug, project_id, workspace_search):
+        fields = ["name", "sequence_id", "project__identifier"]
+        q = Q()
+        if query:
+            for field in fields:
+                if field == "sequence_id":
+                    # Match whole integers only (exclude decimal numbers)
+                    sequences = re.findall(r"\b\d+\b", query)
+                    for sequence_id in sequences:
+                        q |= Q(**{"sequence_id": sequence_id})
+                else:
+                    q |= Q(**{f"{field}__icontains": query})
+
+        issues = Issue.issue_objects.filter(
+            q,
+            project__project_projectmember__member=self.request.user,
+            project__project_projectmember__is_active=True,
+            project__archived_at__isnull=True,
+            workspace__slug=slug,
+        )
+
+        if workspace_search == "false" and project_id:
+            issues = issues.filter(project_id=project_id)
+
+        return issues.distinct().values(
+            "name",
+            "id",
+            "sequence_id",
+            "project__identifier",
+            "project_id",
+            "workspace__slug",
+        )[:100]
+
+    def filter_cycles(self, query, slug, project_id, workspace_search):
+        fields = ["name"]
+        q = Q()
+        if query:
+            for field in fields:
+                q |= Q(**{f"{field}__icontains": query})
+
+        cycles = Cycle.objects.filter(
+            q,
+            project__project_projectmember__member=self.request.user,
+            project__project_projectmember__is_active=True,
+            project__archived_at__isnull=True,
+            workspace__slug=slug,
+        )
+
+        if workspace_search == "false" and project_id:
+            cycles = cycles.filter(project_id=project_id)
+
+        return (
+            cycles.order_by("-created_at")
+            .distinct()
+            .values("name", "id", "project_id", "project__identifier", "workspace__slug")
+        )
+
+    def filter_modules(self, query, slug, project_id, workspace_search):
+        fields = ["name"]
+        q = Q()
+        if query:
+            for field in fields:
+                q |= Q(**{f"{field}__icontains": query})
+
+        modules = Module.objects.filter(
+            q,
+            project__project_projectmember__member=self.request.user,
+            project__project_projectmember__is_active=True,
+            project__archived_at__isnull=True,
+            workspace__slug=slug,
+        )
+
+        if workspace_search == "false" and project_id:
+            modules = modules.filter(project_id=project_id)
+
+        return (
+            modules.order_by("-created_at")
+            .distinct()
+            .values("name", "id", "project_id", "project__identifier", "workspace__slug")
+        )
+
+    def filter_pages(self, query, slug, project_id, workspace_search):
+        fields = ["name"]
+        q = Q()
+        if query:
+            for field in fields:
+                q |= Q(**{f"{field}__icontains": query})
+
+        pages = (
+            Page.objects.filter(
+                q,
+                projects__project_projectmember__member=self.request.user,
+                projects__project_projectmember__is_active=True,
+                projects__archived_at__isnull=True,
+                workspace__slug=slug,
+            )
+            .annotate(
+                project_ids=Coalesce(
+                    ArrayAgg("projects__id", distinct=True, filter=~Q(projects__id=True)),
+                    Value([], output_field=ArrayField(UUIDField())),
+                )
+            )
+            .annotate(
+                project_identifiers=Coalesce(
+                    ArrayAgg(
+                        "projects__identifier",
+                        distinct=True,
+                        filter=~Q(projects__id=True),
+                    ),
+                    Value([], output_field=ArrayField(CharField())),
+                )
+            )
+        )
+
+        if workspace_search == "false" and project_id:
+            project_subquery = ProjectPage.objects.filter(page_id=OuterRef("id"), project_id=project_id).values_list(
+                "project_id", flat=True
+            )[:1]
+
+            pages = pages.annotate(project_id=Subquery(project_subquery)).filter(project_id=project_id)
+
+        return (
+            pages.order_by("-created_at")
+            .distinct()
+            .values("name", "id", "project_ids", "project_identifiers", "workspace__slug")
+        )
+
+    def filter_views(self, query, slug, project_id, workspace_search):
+        fields = ["name"]
+        q = Q()
+        if query:
+            for field in fields:
+                q |= Q(**{f"{field}__icontains": query})
+
+        issue_views = IssueView.objects.filter(
+            q,
+            project__project_projectmember__member=self.request.user,
+            project__project_projectmember__is_active=True,
+            project__archived_at__isnull=True,
+            workspace__slug=slug,
+        )
+
+        if workspace_search == "false" and project_id:
+            issue_views = issue_views.filter(project_id=project_id)
+
+        return (
+            issue_views.order_by("-created_at")
+            .distinct()
+            .values("name", "id", "project_id", "project__identifier", "workspace__slug")
+        )
+
+    def filter_intakes(self, query, slug, project_id, workspace_search):
+        fields = ["name", "sequence_id", "project__identifier"]
+        q = Q()
+        if query:
+            for field in fields:
+                if field == "sequence_id":
+                    # Match whole integers only (exclude decimal numbers)
+                    sequences = re.findall(r"\b\d+\b", query)
+                    for sequence_id in sequences:
+                        q |= Q(**{"sequence_id": sequence_id})
+                else:
+                    q |= Q(**{f"{field}__icontains": query})
+
+        issues = Issue.objects.filter(
+            q,
+            project__project_projectmember__member=self.request.user,
+            project__project_projectmember__is_active=True,
+            project__archived_at__isnull=True,
+            workspace__slug=slug,
+        ).filter(models.Q(issue_intake__status=0) | models.Q(issue_intake__status=-2))
+
+        if workspace_search == "false" and project_id:
+            issues = issues.filter(project_id=project_id)
+
+        return (
+            issues.order_by("-created_at")
+            .distinct()
+            .values(
+                "name",
+                "id",
+                "sequence_id",
+                "project__identifier",
+                "project_id",
+                "workspace__slug",
+            )[:100]
+        )
+
+    def get(self, request, slug):
+        query = request.query_params.get("search", False)
+        entities_param = request.query_params.get("entities")
+        workspace_search = request.query_params.get("workspace_search", "false")
+        project_id = request.query_params.get("project_id", False)
+
+        MODELS_MAPPER = {
+            "workspace": self.filter_workspaces,
+            "project": self.filter_projects,
+            "issue": self.filter_issues,
+            "cycle": self.filter_cycles,
+            "module": self.filter_modules,
+            "issue_view": self.filter_views,
+            "page": self.filter_pages,
+            "intake": self.filter_intakes,
+        }
+
+        # Determine which entities to search
+        if entities_param:
+            requested_entities = [e.strip() for e in entities_param.split(",") if e.strip()]
+            requested_entities = [e for e in requested_entities if e in MODELS_MAPPER]
+        else:
+            requested_entities = list(MODELS_MAPPER.keys())
+
+        results = {}
+
+        for entity in requested_entities:
+            func = MODELS_MAPPER.get(entity)
+            if func:
+                results[entity] = func(query or None, slug, project_id, workspace_search)
+
+        return Response({"results": results}, status=status.HTTP_200_OK)
+
+
+class SearchEndpoint(BaseAPIView):
+    def get(self, request, slug):
+        query = request.query_params.get("query", False)
+        query_types = request.query_params.get("query_type", "user_mention").split(",")
+        query_types = [qt.strip() for qt in query_types]
+        count = int(request.query_params.get("count", 5))
+        project_id = request.query_params.get("project_id", None)
+
+        response_data = {}
+
+        if project_id:
+            for query_type in query_types:
+                if query_type == "user_mention":
+                    fields = [
+                        "member__first_name",
+                        "member__last_name",
+                        "member__display_name",
+                    ]
+                    q = Q()
+
+                    if query:
+                        for field in fields:
+                            q |= Q(**{f"{field}__icontains": query})
+
+                    users = (
+                        ProjectMember.objects.filter(
+                            q,
+                            is_active=True,
+                            workspace__slug=slug,
+                            member__is_bot=False,
+                            project_id=project_id,
+                        )
+                        .annotate(
+                            member__avatar_url=Case(
+                                When(
+                                    member__avatar_asset__isnull=False,
+                                    then=Concat(
+                                        Value("/api/assets/v2/static/"),
+                                        "member__avatar_asset",
+                                        Value("/"),
+                                    ),
+                                ),
+                                When(
+                                    member__avatar_asset__isnull=True,
+                                    then="member__avatar",
+                                ),
+                                default=Value(None),
+                                output_field=CharField(),
+                            )
+                        )
+                        .order_by("-created_at")
+                    )
+
+                    users = users.distinct().values(
+                        "member__avatar_url",
+                        "member__display_name",
+                        "member__id",
+                    )
+
+                    response_data["user_mention"] = list(users[:count])
+
+                elif query_type == "project":
+                    fields = ["name", "identifier"]
+                    q = Q()
+
+                    if query:
+                        for field in fields:
+                            q |= Q(**{f"{field}__icontains": query})
+                    projects = (
+                        Project.objects.filter(
+                            q,
+                            Q(project_projectmember__member=self.request.user) | Q(network=2),
+                            workspace__slug=slug,
+                        )
+                        .order_by("-created_at")
+                        .distinct()
+                        .values("name", "id", "identifier", "logo_props", "workspace__slug")[:count]
+                    )
+                    response_data["project"] = list(projects)
+
+                elif query_type == "issue":
+                    fields = ["name", "sequence_id", "project__identifier"]
+                    q = Q()
+
+                    if query:
+                        for field in fields:
+                            if field == "sequence_id":
+                                sequences = re.findall(r"\b\d+\b", query)
+                                for sequence_id in sequences:
+                                    q |= Q(**{"sequence_id": sequence_id})
+                            else:
+                                q |= Q(**{f"{field}__icontains": query})
+
+                    issues = (
+                        Issue.issue_objects.filter(
+                            q,
+                            project__project_projectmember__member=self.request.user,
+                            project__project_projectmember__is_active=True,
+                            workspace__slug=slug,
+                            project_id=project_id,
+                        )
+                        .order_by("-created_at")
+                        .distinct()
+                        .values(
+                            "name",
+                            "id",
+                            "sequence_id",
+                            "project__identifier",
+                            "project_id",
+                            "priority",
+                            "state_id",
+                            "type_id",
+                        )[:count]
+                    )
+                    response_data["issue"] = list(issues)
+
+                elif query_type == "cycle":
+                    fields = ["name"]
+                    q = Q()
+
+                    if query:
+                        for field in fields:
+                            q |= Q(**{f"{field}__icontains": query})
+
+                    cycles = (
+                        Cycle.objects.filter(
+                            q,
+                            project__project_projectmember__member=self.request.user,
+                            project__project_projectmember__is_active=True,
+                            workspace__slug=slug,
+                            project_id=project_id,
+                        )
+                        .annotate(
+                            status=Case(
+                                When(
+                                    Q(start_date__lte=timezone.now()) & Q(end_date__gte=timezone.now()),
+                                    then=Value("CURRENT"),
+                                ),
+                                When(
+                                    start_date__gt=timezone.now(),
+                                    then=Value("UPCOMING"),
+                                ),
+                                When(end_date__lt=timezone.now(), then=Value("COMPLETED")),
+                                When(
+                                    Q(start_date__isnull=True) & Q(end_date__isnull=True),
+                                    then=Value("DRAFT"),
+                                ),
+                                default=Value("DRAFT"),
+                                output_field=CharField(),
+                            )
+                        )
+                        .order_by("-created_at")
+                        .distinct()
+                        .values(
+                            "name",
+                            "id",
+                            "project_id",
+                            "project__identifier",
+                            "status",
+                            "workspace__slug",
+                        )[:count]
+                    )
+                    response_data["cycle"] = list(cycles)
+
+                elif query_type == "module":
+                    fields = ["name"]
+                    q = Q()
+
+                    if query:
+                        for field in fields:
+                            q |= Q(**{f"{field}__icontains": query})
+
+                    modules = (
+                        Module.objects.filter(
+                            q,
+                            project__project_projectmember__member=self.request.user,
+                            project__project_projectmember__is_active=True,
+                            workspace__slug=slug,
+                            project_id=project_id,
+                        )
+                        .order_by("-created_at")
+                        .distinct()
+                        .values(
+                            "name",
+                            "id",
+                            "project_id",
+                            "project__identifier",
+                            "status",
+                            "workspace__slug",
+                        )[:count]
+                    )
+                    response_data["module"] = list(modules)
+
+                elif query_type == "page":
+                    fields = ["name"]
+                    q = Q()
+
+                    if query:
+                        for field in fields:
+                            q |= Q(**{f"{field}__icontains": query})
+
+                    pages = (
+                        Page.objects.filter(
+                            q,
+                            projects__project_projectmember__member=self.request.user,
+                            projects__project_projectmember__is_active=True,
+                            projects__id=project_id,
+                            workspace__slug=slug,
+                            access=0,
+                        )
+                        .order_by("-created_at")
+                        .distinct()
+                        .values(
+                            "name",
+                            "id",
+                            "logo_props",
+                            "projects__id",
+                            "workspace__slug",
+                        )[:count]
+                    )
+                    response_data["page"] = list(pages)
+            return Response(response_data, status=status.HTTP_200_OK)
+
+        else:
+            for query_type in query_types:
+                if query_type == "user_mention":
+                    fields = [
+                        "member__first_name",
+                        "member__last_name",
+                        "member__display_name",
+                    ]
+                    q = Q()
+
+                    if query:
+                        for field in fields:
+                            q |= Q(**{f"{field}__icontains": query})
+                    users = (
+                        WorkspaceMember.objects.filter(
+                            q,
+                            is_active=True,
+                            workspace__slug=slug,
+                            member__is_bot=False,
+                        )
+                        .annotate(
+                            member__avatar_url=Case(
+                                When(
+                                    member__avatar_asset__isnull=False,
+                                    then=Concat(
+                                        Value("/api/assets/v2/static/"),
+                                        "member__avatar_asset",
+                                        Value("/"),
+                                    ),
+                                ),
+                                When(
+                                    member__avatar_asset__isnull=True,
+                                    then="member__avatar",
+                                ),
+                                default=Value(None),
+                                output_field=models.CharField(),
+                            )
+                        )
+                        .order_by("-created_at")
+                        .values("member__avatar_url", "member__display_name", "member__id")[:count]
+                    )
+                    response_data["user_mention"] = list(users)
+
+                elif query_type == "project":
+                    fields = ["name", "identifier"]
+                    q = Q()
+
+                    if query:
+                        for field in fields:
+                            q |= Q(**{f"{field}__icontains": query})
+                    projects = (
+                        Project.objects.filter(
+                            q,
+                            Q(project_projectmember__member=self.request.user) | Q(network=2),
+                            workspace__slug=slug,
+                        )
+                        .order_by("-created_at")
+                        .distinct()
+                        .values("name", "id", "identifier", "logo_props", "workspace__slug")[:count]
+                    )
+                    response_data["project"] = list(projects)
+
+                elif query_type == "issue":
+                    fields = ["name", "sequence_id", "project__identifier"]
+                    q = Q()
+
+                    if query:
+                        for field in fields:
+                            if field == "sequence_id":
+                                sequences = re.findall(r"\b\d+\b", query)
+                                for sequence_id in sequences:
+                                    q |= Q(**{"sequence_id": sequence_id})
+                            else:
+                                q |= Q(**{f"{field}__icontains": query})
+
+                    issues = (
+                        Issue.issue_objects.filter(
+                            q,
+                            project__project_projectmember__member=self.request.user,
+                            project__project_projectmember__is_active=True,
+                            workspace__slug=slug,
+                        )
+                        .order_by("-created_at")
+                        .distinct()
+                        .values(
+                            "name",
+                            "id",
+                            "sequence_id",
+                            "project__identifier",
+                            "project_id",
+                            "priority",
+                            "state_id",
+                            "type_id",
+                        )[:count]
+                    )
+                    response_data["issue"] = list(issues)
+
+                elif query_type == "cycle":
+                    fields = ["name"]
+                    q = Q()
+
+                    if query:
+                        for field in fields:
+                            q |= Q(**{f"{field}__icontains": query})
+
+                    cycles = (
+                        Cycle.objects.filter(
+                            q,
+                            project__project_projectmember__member=self.request.user,
+                            project__project_projectmember__is_active=True,
+                            workspace__slug=slug,
+                        )
+                        .annotate(
+                            status=Case(
+                                When(
+                                    Q(start_date__lte=timezone.now()) & Q(end_date__gte=timezone.now()),
+                                    then=Value("CURRENT"),
+                                ),
+                                When(
+                                    start_date__gt=timezone.now(),
+                                    then=Value("UPCOMING"),
+                                ),
+                                When(end_date__lt=timezone.now(), then=Value("COMPLETED")),
+                                When(
+                                    Q(start_date__isnull=True) & Q(end_date__isnull=True),
+                                    then=Value("DRAFT"),
+                                ),
+                                default=Value("DRAFT"),
+                                output_field=CharField(),
+                            )
+                        )
+                        .order_by("-created_at")
+                        .distinct()
+                        .values(
+                            "name",
+                            "id",
+                            "project_id",
+                            "project__identifier",
+                            "status",
+                            "workspace__slug",
+                        )[:count]
+                    )
+                    response_data["cycle"] = list(cycles)
+
+                elif query_type == "module":
+                    fields = ["name"]
+                    q = Q()
+
+                    if query:
+                        for field in fields:
+                            q |= Q(**{f"{field}__icontains": query})
+
+                    modules = (
+                        Module.objects.filter(
+                            q,
+                            project__project_projectmember__member=self.request.user,
+                            project__project_projectmember__is_active=True,
+                            workspace__slug=slug,
+                        )
+                        .order_by("-created_at")
+                        .distinct()
+                        .values(
+                            "name",
+                            "id",
+                            "project_id",
+                            "project__identifier",
+                            "status",
+                            "workspace__slug",
+                        )[:count]
+                    )
+                    response_data["module"] = list(modules)
+
+                elif query_type == "page":
+                    fields = ["name"]
+                    q = Q()
+
+                    if query:
+                        for field in fields:
+                            q |= Q(**{f"{field}__icontains": query})
+
+                    pages = (
+                        Page.objects.filter(
+                            q,
+                            projects__project_projectmember__member=self.request.user,
+                            projects__project_projectmember__is_active=True,
+                            workspace__slug=slug,
+                            access=0,
+                            is_global=True,
+                        )
+                        .order_by("-created_at")
+                        .distinct()
+                        .values(
+                            "name",
+                            "id",
+                            "logo_props",
+                            "projects__id",
+                            "workspace__slug",
+                        )[:count]
+                    )
+                    response_data["page"] = list(pages)
+            return Response(response_data, status=status.HTTP_200_OK)

plane-src/apps/api/plane/app/views/search/issue.py

@@ -0,0 +1,161 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+# Django imports
+from django.db.models import Q, QuerySet
+
+# Third party imports
+from rest_framework import status
+from rest_framework.response import Response
+
+# Module imports
+from .base import BaseAPIView
+from plane.db.models import Issue, ProjectMember, IssueRelation
+from plane.utils.issue_search import search_issues
+
+
+class IssueSearchEndpoint(BaseAPIView):
+    def filter_issues_by_project(self, project_id: int, issues: QuerySet) -> QuerySet:
+        """
+        Filter issues by project
+        """
+
+        issues = issues.filter(project_id=project_id)
+
+        return issues
+
+    def search_issues_by_query(self, query: str, issues: QuerySet) -> QuerySet:
+        """
+        Search issues by query
+        """
+
+        issues = search_issues(query, issues)
+
+        return issues
+
+    def search_issues_and_excluding_parent(self, issues: QuerySet, issue_id: str) -> QuerySet:
+        """
+        Search issues and epics by query excluding the parent
+        """
+
+        issue = Issue.issue_objects.filter(pk=issue_id).first()
+        if issue:
+            issues = issues.filter(~Q(pk=issue_id), ~Q(pk=issue.parent_id), ~Q(parent_id=issue_id))
+        return issues
+
+    def filter_issues_excluding_related_issues(self, issue_id: str, issues: QuerySet) -> QuerySet:
+        """
+        Filter issues excluding related issues
+        """
+
+        issue = Issue.issue_objects.filter(pk=issue_id).first()
+        related_issue_ids = (
+            IssueRelation.objects.filter(Q(related_issue=issue) | Q(issue=issue))
+            .values_list("issue_id", "related_issue_id")
+            .distinct()
+        )
+
+        related_issue_ids = [item for sublist in related_issue_ids for item in sublist]
+        related_issue_ids.append(issue_id)
+
+        if issue:
+            issues = issues.exclude(pk__in=related_issue_ids)
+
+        return issues
+
+    def filter_root_issues_only(self, issue_id: str, issues: QuerySet) -> QuerySet:
+        """
+        Filter root issues only
+        """
+        issue = Issue.issue_objects.filter(pk=issue_id).first()
+        if issue:
+            issues = issues.filter(~Q(pk=issue_id), parent__isnull=True)
+        if issue.parent:
+            issues = issues.filter(~Q(pk=issue.parent_id))
+        return issues
+
+    def exclude_issues_in_cycles(self, issues: QuerySet) -> QuerySet:
+        """
+        Exclude issues in cycles
+        """
+        issues = issues.exclude(Q(issue_cycle__isnull=False) & Q(issue_cycle__deleted_at__isnull=True))
+        return issues
+
+    def exclude_issues_in_module(self, issues: QuerySet, module: str) -> QuerySet:
+        """
+        Exclude issues in a module
+        """
+        issues = issues.exclude(Q(issue_module__module=module) & Q(issue_module__deleted_at__isnull=True))
+        return issues
+
+    def filter_issues_without_target_date(self, issues: QuerySet) -> QuerySet:
+        """
+        Filter issues without a target date
+        """
+        issues = issues.filter(target_date__isnull=True)
+        return issues
+
+    def get(self, request, slug, project_id):
+        query = request.query_params.get("search", False)
+        workspace_search = request.query_params.get("workspace_search", "false")
+        parent = request.query_params.get("parent", "false")
+        issue_relation = request.query_params.get("issue_relation", "false")
+        cycle = request.query_params.get("cycle", "false")
+        module = request.query_params.get("module", False)
+        sub_issue = request.query_params.get("sub_issue", "false")
+        target_date = request.query_params.get("target_date", True)
+        issue_id = request.query_params.get("issue_id", False)
+
+        issues = Issue.issue_objects.filter(
+            workspace__slug=slug,
+            project__project_projectmember__member=self.request.user,
+            project__project_projectmember__is_active=True,
+            project__archived_at__isnull=True,
+        )
+
+        if workspace_search == "false":
+            issues = self.filter_issues_by_project(project_id, issues)
+
+        if query:
+            issues = self.search_issues_by_query(query, issues)
+
+        if parent == "true" and issue_id:
+            issues = self.search_issues_and_excluding_parent(issues, issue_id)
+
+        if issue_relation == "true" and issue_id:
+            issues = self.filter_issues_excluding_related_issues(issue_id, issues)
+
+        if sub_issue == "true" and issue_id:
+            issues = self.filter_root_issues_only(issue_id, issues)
+
+        if cycle == "true":
+            issues = self.exclude_issues_in_cycles(issues)
+
+        if module:
+            issues = self.exclude_issues_in_module(issues, module)
+
+        if target_date == "none":
+            issues = self.filter_issues_without_target_date(issues)
+
+        if ProjectMember.objects.filter(
+            project_id=project_id, member=self.request.user, is_active=True, role=5
+        ).exists():
+            issues = issues.filter(created_by=self.request.user)
+
+        return Response(
+            issues.values(
+                "name",
+                "id",
+                "start_date",
+                "sequence_id",
+                "project__name",
+                "project__identifier",
+                "project_id",
+                "workspace__slug",
+                "state__name",
+                "state__group",
+                "state__color",
+            )[:100],
+            status=status.HTTP_200_OK,
+        )

plane-src/apps/api/plane/app/views/state/base.py

@@ -0,0 +1,146 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+# Python imports
+from itertools import groupby
+from collections import defaultdict
+
+# Django imports
+from django.db.utils import IntegrityError
+
+# Third party imports
+from rest_framework.response import Response
+from rest_framework import status
+
+# Module imports
+from .. import BaseViewSet, BaseAPIView
+from plane.app.serializers import StateSerializer
+from plane.app.permissions import ROLE, allow_permission
+from plane.db.models import State, Issue
+from plane.utils.cache import invalidate_cache
+
+
+class StateViewSet(BaseViewSet):
+    serializer_class = StateSerializer
+    model = State
+
+    def get_queryset(self):
+        return self.filter_queryset(
+            super()
+            .get_queryset()
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .filter(project_id=self.kwargs.get("project_id"))
+            .filter(
+                project__project_projectmember__member=self.request.user,
+                project__project_projectmember__is_active=True,
+                project__archived_at__isnull=True,
+            )
+            .filter(is_triage=False)
+            .select_related("project")
+            .select_related("workspace")
+            .distinct()
+        )
+
+    @invalidate_cache(path="workspaces/:slug/states/", url_params=True, user=False)
+    @allow_permission([ROLE.ADMIN])
+    def create(self, request, slug, project_id):
+        try:
+            serializer = StateSerializer(data=request.data)
+            if serializer.is_valid():
+                serializer.save(project_id=project_id)
+                return Response(serializer.data, status=status.HTTP_200_OK)
+            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+        except IntegrityError as e:
+            if "already exists" in str(e):
+                return Response(
+                    {"name": "The state name is already taken"},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
+    def partial_update(self, request, slug, project_id, pk):
+        try:
+            state = State.objects.get(pk=pk, project_id=project_id, workspace__slug=slug)
+            serializer = StateSerializer(state, data=request.data, partial=True)
+            if serializer.is_valid():
+                serializer.save()
+                return Response(serializer.data, status=status.HTTP_200_OK)
+            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+        except IntegrityError as e:
+            if "already exists" in str(e):
+                return Response(
+                    {"name": "The state name is already taken"},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
+    def list(self, request, slug, project_id):
+        states = StateSerializer(self.get_queryset(), many=True).data
+
+        grouped_states = defaultdict(list)
+        for state in states:
+            grouped_states[state["group"]].append(state)
+
+        for group, group_states in grouped_states.items():
+            count = len(group_states)
+
+            for index, state in enumerate(group_states, start=1):
+                state["order"] = index / count
+
+        grouped = request.GET.get("grouped", False)
+
+        if grouped == "true":
+            state_dict = {}
+            for key, value in groupby(
+                sorted(states, key=lambda state: state["group"]),
+                lambda state: state.get("group"),
+            ):
+                state_dict[str(key)] = list(value)
+            return Response(state_dict, status=status.HTTP_200_OK)
+
+        return Response(states, status=status.HTTP_200_OK)
+
+    @invalidate_cache(path="workspaces/:slug/states/", url_params=True, user=False)
+    @allow_permission([ROLE.ADMIN])
+    def mark_as_default(self, request, slug, project_id, pk):
+        # Select all the states which are marked as default
+        _ = State.objects.filter(workspace__slug=slug, project_id=project_id, default=True).update(default=False)
+        _ = State.objects.filter(workspace__slug=slug, project_id=project_id, pk=pk).update(default=True)
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+    @invalidate_cache(path="workspaces/:slug/states/", url_params=True, user=False)
+    @allow_permission([ROLE.ADMIN])
+    def destroy(self, request, slug, project_id, pk):
+        state = State.objects.get(is_triage=False, pk=pk, 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.objects.filter(state=pk).exists()
+
+        if issue_exist:
+            return Response(
+                {"error": "The state is not empty, only empty states can be deleted"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        state.delete()
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+class IntakeStateEndpoint(BaseAPIView):
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
+    def get(self, request, slug, project_id):
+        state = State.triage_objects.filter(workspace__slug=slug, project_id=project_id).first()
+        if not state:
+            return Response(
+                {"error": "Triage state not found"},
+                status=status.HTTP_404_NOT_FOUND,
+            )
+
+        return Response(StateSerializer(state).data, status=status.HTTP_200_OK)

plane-src/apps/api/plane/app/views/timezone/base.py

@@ -0,0 +1,215 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+# Python imports
+import pytz
+from datetime import datetime
+
+# Django imports
+from django.utils.decorators import method_decorator
+from django.views.decorators.cache import cache_page
+
+# Third party imports
+from rest_framework import status
+from rest_framework.response import Response
+from rest_framework.permissions import AllowAny
+from rest_framework.views import APIView
+
+# Module imports
+from plane.authentication.rate_limit import AuthenticationThrottle
+
+
+class TimezoneEndpoint(APIView):
+    permission_classes = [AllowAny]
+
+    throttle_classes = [AuthenticationThrottle]
+
+    @method_decorator(cache_page(60 * 60 * 2))
+    def get(self, request):
+        timezone_locations = [
+            ("Midway Island", "Pacific/Midway"),  # UTC-11:00
+            ("American Samoa", "Pacific/Pago_Pago"),  # UTC-11:00
+            ("Hawaii", "Pacific/Honolulu"),  # UTC-10:00
+            ("Aleutian Islands", "America/Adak"),  # UTC-10:00 (DST: UTC-09:00)
+            ("Marquesas Islands", "Pacific/Marquesas"),  # UTC-09:30
+            ("Alaska", "America/Anchorage"),  # UTC-09:00 (DST: UTC-08:00)
+            ("Gambier Islands", "Pacific/Gambier"),  # UTC-09:00
+            (
+                "Pacific Time (US and Canada)",
+                "America/Los_Angeles",
+            ),  # UTC-08:00 (DST: UTC-07:00)
+            ("Baja California", "America/Tijuana"),  # UTC-08:00 (DST: UTC-07:00)
+            (
+                "Mountain Time (US and Canada)",
+                "America/Denver",
+            ),  # UTC-07:00 (DST: UTC-06:00)
+            ("Arizona", "America/Phoenix"),  # UTC-07:00
+            ("Chihuahua, Mazatlan", "America/Chihuahua"),  # UTC-07:00 (DST: UTC-06:00)
+            (
+                "Central Time (US and Canada)",
+                "America/Chicago",
+            ),  # UTC-06:00 (DST: UTC-05:00)
+            ("Saskatchewan", "America/Regina"),  # UTC-06:00
+            (
+                "Guadalajara, Mexico City, Monterrey",
+                "America/Mexico_City",
+            ),  # UTC-06:00 (DST: UTC-05:00)
+            ("Tegucigalpa, Honduras", "America/Tegucigalpa"),  # UTC-06:00
+            ("Costa Rica", "America/Costa_Rica"),  # UTC-06:00
+            (
+                "Eastern Time (US and Canada)",
+                "America/New_York",
+            ),  # UTC-05:00 (DST: UTC-04:00)
+            ("Lima", "America/Lima"),  # UTC-05:00
+            ("Bogota", "America/Bogota"),  # UTC-05:00
+            ("Quito", "America/Guayaquil"),  # UTC-05:00
+            ("Chetumal", "America/Cancun"),  # UTC-05:00 (DST: UTC-04:00)
+            ("Caracas (Old Venezuela Time)", "America/Caracas"),  # UTC-04:30
+            ("Atlantic Time (Canada)", "America/Halifax"),  # UTC-04:00 (DST: UTC-03:00)
+            ("Caracas", "America/Caracas"),  # UTC-04:00
+            ("Santiago", "America/Santiago"),  # UTC-04:00 (DST: UTC-03:00)
+            ("La Paz", "America/La_Paz"),  # UTC-04:00
+            ("Manaus", "America/Manaus"),  # UTC-04:00
+            ("Georgetown", "America/Guyana"),  # UTC-04:00
+            ("Bermuda", "Atlantic/Bermuda"),  # UTC-04:00 (DST: UTC-03:00)
+            (
+                "Newfoundland Time (Canada)",
+                "America/St_Johns",
+            ),  # UTC-03:30 (DST: UTC-02:30)
+            ("Buenos Aires", "America/Argentina/Buenos_Aires"),  # UTC-03:00
+            ("Brasilia", "America/Sao_Paulo"),  # UTC-03:00
+            ("Greenland", "America/Godthab"),  # UTC-03:00 (DST: UTC-02:00)
+            ("Montevideo", "America/Montevideo"),  # UTC-03:00
+            ("Falkland Islands", "Atlantic/Stanley"),  # UTC-03:00
+            (
+                "South Georgia and the South Sandwich Islands",
+                "Atlantic/South_Georgia",
+            ),  # UTC-02:00
+            ("Azores", "Atlantic/Azores"),  # UTC-01:00 (DST: UTC+00:00)
+            ("Cape Verde Islands", "Atlantic/Cape_Verde"),  # UTC-01:00
+            ("Dublin", "Europe/Dublin"),  # UTC+00:00 (DST: UTC+01:00)
+            ("Reykjavik", "Atlantic/Reykjavik"),  # UTC+00:00
+            ("Lisbon", "Europe/Lisbon"),  # UTC+00:00 (DST: UTC+01:00)
+            ("Monrovia", "Africa/Monrovia"),  # UTC+00:00
+            ("Casablanca", "Africa/Casablanca"),  # UTC+00:00 (DST: UTC+01:00)
+            (
+                "Central European Time (Berlin, Rome, Paris)",
+                "Europe/Paris",
+            ),  # UTC+01:00 (DST: UTC+02:00)
+            ("West Central Africa", "Africa/Lagos"),  # UTC+01:00
+            ("Algiers", "Africa/Algiers"),  # UTC+01:00
+            ("Lagos", "Africa/Lagos"),  # UTC+01:00
+            ("Tunis", "Africa/Tunis"),  # UTC+01:00
+            (
+                "Eastern European Time (Cairo, Helsinki, Kyiv)",
+                "Europe/Kyiv",
+            ),  # UTC+02:00 (DST: UTC+03:00)
+            ("Athens", "Europe/Athens"),  # UTC+02:00 (DST: UTC+03:00)
+            ("Jerusalem", "Asia/Jerusalem"),  # UTC+02:00 (DST: UTC+03:00)
+            ("Johannesburg", "Africa/Johannesburg"),  # UTC+02:00
+            ("Harare, Pretoria", "Africa/Harare"),  # UTC+02:00
+            ("Moscow Time", "Europe/Moscow"),  # UTC+03:00
+            ("Baghdad", "Asia/Baghdad"),  # UTC+03:00
+            ("Nairobi", "Africa/Nairobi"),  # UTC+03:00
+            ("Kuwait, Riyadh", "Asia/Riyadh"),  # UTC+03:00
+            ("Tehran", "Asia/Tehran"),  # UTC+03:30 (DST: UTC+04:30)
+            ("Abu Dhabi", "Asia/Dubai"),  # UTC+04:00
+            ("Baku", "Asia/Baku"),  # UTC+04:00 (DST: UTC+05:00)
+            ("Yerevan", "Asia/Yerevan"),  # UTC+04:00 (DST: UTC+05:00)
+            ("Astrakhan", "Europe/Astrakhan"),  # UTC+04:00
+            ("Tbilisi", "Asia/Tbilisi"),  # UTC+04:00
+            ("Mauritius", "Indian/Mauritius"),  # UTC+04:00
+            ("Kabul", "Asia/Kabul"),  # UTC+04:30
+            ("Islamabad", "Asia/Karachi"),  # UTC+05:00
+            ("Karachi", "Asia/Karachi"),  # UTC+05:00
+            ("Tashkent", "Asia/Tashkent"),  # UTC+05:00
+            ("Yekaterinburg", "Asia/Yekaterinburg"),  # UTC+05:00
+            ("Maldives", "Indian/Maldives"),  # UTC+05:00
+            ("Chagos", "Indian/Chagos"),  # UTC+05:00
+            ("Chennai", "Asia/Kolkata"),  # UTC+05:30
+            ("Kolkata", "Asia/Kolkata"),  # UTC+05:30
+            ("Mumbai", "Asia/Kolkata"),  # UTC+05:30
+            ("New Delhi", "Asia/Kolkata"),  # UTC+05:30
+            ("Sri Jayawardenepura", "Asia/Colombo"),  # UTC+05:30
+            ("Kathmandu", "Asia/Kathmandu"),  # UTC+05:45
+            ("Dhaka", "Asia/Dhaka"),  # UTC+06:00
+            ("Almaty", "Asia/Almaty"),  # UTC+06:00
+            ("Bishkek", "Asia/Bishkek"),  # UTC+06:00
+            ("Thimphu", "Asia/Thimphu"),  # UTC+06:00
+            ("Yangon (Rangoon)", "Asia/Yangon"),  # UTC+06:30
+            ("Cocos Islands", "Indian/Cocos"),  # UTC+06:30
+            ("Bangkok", "Asia/Bangkok"),  # UTC+07:00
+            ("Hanoi", "Asia/Ho_Chi_Minh"),  # UTC+07:00
+            ("Jakarta", "Asia/Jakarta"),  # UTC+07:00
+            ("Novosibirsk", "Asia/Novosibirsk"),  # UTC+07:00
+            ("Krasnoyarsk", "Asia/Krasnoyarsk"),  # UTC+07:00
+            ("Beijing", "Asia/Shanghai"),  # UTC+08:00
+            ("Singapore", "Asia/Singapore"),  # UTC+08:00
+            ("Perth", "Australia/Perth"),  # UTC+08:00
+            ("Hong Kong", "Asia/Hong_Kong"),  # UTC+08:00
+            ("Ulaanbaatar", "Asia/Ulaanbaatar"),  # UTC+08:00
+            ("Palau", "Pacific/Palau"),  # UTC+08:00
+            ("Eucla", "Australia/Eucla"),  # UTC+08:45
+            ("Tokyo", "Asia/Tokyo"),  # UTC+09:00
+            ("Seoul", "Asia/Seoul"),  # UTC+09:00
+            ("Yakutsk", "Asia/Yakutsk"),  # UTC+09:00
+            ("Adelaide", "Australia/Adelaide"),  # UTC+09:30 (DST: UTC+10:30)
+            ("Darwin", "Australia/Darwin"),  # UTC+09:30
+            ("Sydney", "Australia/Sydney"),  # UTC+10:00 (DST: UTC+11:00)
+            ("Brisbane", "Australia/Brisbane"),  # UTC+10:00
+            ("Guam", "Pacific/Guam"),  # UTC+10:00
+            ("Vladivostok", "Asia/Vladivostok"),  # UTC+10:00
+            ("Tahiti", "Pacific/Tahiti"),  # UTC+10:00
+            ("Lord Howe Island", "Australia/Lord_Howe"),  # UTC+10:30 (DST: UTC+11:00)
+            ("Solomon Islands", "Pacific/Guadalcanal"),  # UTC+11:00
+            ("Magadan", "Asia/Magadan"),  # UTC+11:00
+            ("Norfolk Island", "Pacific/Norfolk"),  # UTC+11:00
+            ("Bougainville Island", "Pacific/Bougainville"),  # UTC+11:00
+            ("Chokurdakh", "Asia/Srednekolymsk"),  # UTC+11:00
+            ("Auckland", "Pacific/Auckland"),  # UTC+12:00 (DST: UTC+13:00)
+            ("Wellington", "Pacific/Auckland"),  # UTC+12:00 (DST: UTC+13:00)
+            ("Fiji Islands", "Pacific/Fiji"),  # UTC+12:00 (DST: UTC+13:00)
+            ("Anadyr", "Asia/Anadyr"),  # UTC+12:00
+            ("Chatham Islands", "Pacific/Chatham"),  # UTC+12:45 (DST: UTC+13:45)
+            ("Nuku'alofa", "Pacific/Tongatapu"),  # UTC+13:00
+            ("Samoa", "Pacific/Apia"),  # UTC+13:00 (DST: UTC+14:00)
+            ("Kiritimati Island", "Pacific/Kiritimati"),  # UTC+14:00
+        ]
+
+        timezone_list = []
+        now = datetime.now()
+
+        # Process timezone mapping
+        for friendly_name, tz_identifier in timezone_locations:
+            try:
+                tz = pytz.timezone(tz_identifier)
+                current_offset = now.astimezone(tz).strftime("%z")
+
+                # converting and formatting UTC offset to GMT offset
+                current_utc_offset = now.astimezone(tz).utcoffset()
+                total_seconds = int(current_utc_offset.total_seconds())
+                hours_offset = total_seconds // 3600
+                minutes_offset = abs(total_seconds % 3600) // 60
+                offset = f"{'+' if hours_offset >= 0 else '-'}{abs(hours_offset):02}:{minutes_offset:02}"
+
+                timezone_value = {
+                    "offset": int(current_offset),
+                    "utc_offset": f"UTC{offset}",
+                    "gmt_offset": f"GMT{offset}",
+                    "value": tz_identifier,
+                    "label": f"{friendly_name}",
+                }
+
+                timezone_list.append(timezone_value)
+            except pytz.exceptions.UnknownTimeZoneError:
+                continue
+
+        # Sort by offset and then by label
+        timezone_list.sort(key=lambda x: (x["offset"], x["label"]))
+
+        # Remove offset from final output
+        for tz in timezone_list:
+            del tz["offset"]
+
+        return Response({"timezones": timezone_list}, status=status.HTTP_200_OK)

plane-src/apps/api/plane/app/views/user/base.py

@@ -0,0 +1,425 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+# Python imports
+import uuid
+import json
+import logging
+import secrets
+
+# Django imports
+from django.db.models import Case, Count, IntegerField, Q, When
+from django.contrib.auth import logout
+from django.utils import timezone
+from django.utils.decorators import method_decorator
+from django.views.decorators.cache import cache_control
+from django.views.decorators.vary import vary_on_cookie
+from django.core.validators import validate_email
+from django.core.cache import cache
+
+# Third party imports
+from rest_framework import status
+from rest_framework.response import Response
+from rest_framework.permissions import AllowAny
+
+# Module imports
+from plane.app.serializers import (
+    AccountSerializer,
+    IssueActivitySerializer,
+    ProfileSerializer,
+    UserMeSerializer,
+    UserMeSettingsSerializer,
+    UserSerializer,
+)
+from plane.app.views.base import BaseAPIView, BaseViewSet
+from plane.db.models import (
+    Account,
+    IssueActivity,
+    Profile,
+    ProjectMember,
+    User,
+    WorkspaceMember,
+    WorkspaceMemberInvite,
+    Session,
+)
+from plane.license.models import Instance, InstanceAdmin
+from plane.utils.paginator import BasePaginator
+from plane.authentication.utils.host import user_ip
+from plane.bgtasks.user_deactivation_email_task import user_deactivation_email
+from plane.utils.host import base_host
+from plane.bgtasks.user_email_update_task import send_email_update_magic_code, send_email_update_confirmation
+from plane.authentication.rate_limit import EmailVerificationThrottle
+
+
+logger = logging.getLogger("plane")
+
+
+class UserEndpoint(BaseViewSet):
+    serializer_class = UserSerializer
+    model = User
+    use_read_replica = True
+
+    def get_object(self):
+        return self.request.user
+
+    def get_throttles(self):
+        """
+        Apply rate limiting to specific endpoints.
+        """
+        if self.action == "generate_email_verification_code":
+            return [EmailVerificationThrottle()]
+        return super().get_throttles()
+
+    @method_decorator(cache_control(private=True, max_age=12))
+    @method_decorator(vary_on_cookie)
+    def retrieve(self, request):
+        serialized_data = UserMeSerializer(request.user).data
+        return Response(serialized_data, status=status.HTTP_200_OK)
+
+    @method_decorator(cache_control(private=True, max_age=12))
+    @method_decorator(vary_on_cookie)
+    def retrieve_user_settings(self, request):
+        serialized_data = UserMeSettingsSerializer(request.user).data
+        return Response(serialized_data, status=status.HTTP_200_OK)
+
+    def retrieve_instance_admin(self, request):
+        instance = Instance.objects.first()
+        is_admin = InstanceAdmin.objects.filter(instance=instance, user=request.user).exists()
+        return Response({"is_instance_admin": is_admin}, status=status.HTTP_200_OK)
+
+    def partial_update(self, request, *args, **kwargs):
+        return super().partial_update(request, *args, **kwargs)
+
+    def _validate_new_email(self, user, new_email):
+        """
+        Validate the new email address.
+
+        Args:
+            user: The User instance
+            new_email: The new email address to validate
+
+        Returns:
+            Response object with error if validation fails, None if validation passes
+        """
+        if not new_email:
+            return Response(
+                {"error": "Email is required"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # Validate email format
+        try:
+            validate_email(new_email)
+        except Exception:
+            return Response(
+                {"error": "Invalid email format"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # Check if email is the same as current email
+        if new_email == user.email:
+            return Response(
+                {"error": "New email must be different from current email"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # Check if email already exists in the User model
+        if User.objects.filter(email=new_email).exclude(id=user.id).exists():
+            return Response(
+                {"error": "An account with this email already exists"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        return None
+
+    def generate_email_verification_code(self, request):
+        """
+        Generate and send a magic code to the new email address for verification.
+        Rate limited to 3 requests per hour per user (enforced by EmailVerificationThrottle).
+        Additional per-email cooldown of 60 seconds prevents rapid repeated requests.
+        """
+        user = self.get_object()
+        new_email = request.data.get("email", "").strip().lower()
+
+        # Validate the new email
+        validation_error = self._validate_new_email(user, new_email)
+        if validation_error:
+            return validation_error
+
+        try:
+            # Generate magic code for email verification
+            # Use a special key prefix to distinguish from regular magic signin
+            # Include user ID to bind the code to the specific user
+            cache_key = f"magic_email_update_{user.id}_{new_email}"
+            ## Generate a random token
+            token = str(secrets.randbelow(900000) + 100000)
+            # Store in cache with 10 minute expiration
+            cache_data = json.dumps({"token": token})
+            cache.set(cache_key, cache_data, timeout=600)
+
+            # Send magic code to the new email
+            send_email_update_magic_code.delay(new_email, token)
+
+            return Response(
+                {"message": "Verification code sent to email"},
+                status=status.HTTP_200_OK,
+            )
+        except Exception as e:
+            logger.error("Failed to generate verification code: %s", str(e), exc_info=True)
+            return Response(
+                {"error": "Failed to generate verification code. Please try again."},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+    def update_email(self, request):
+        """
+        Verify the magic code and update the user's email address.
+        This endpoint verifies the code and updates the existing user record
+        without creating a new user, ensuring the user ID remains unchanged.
+        """
+        user = self.get_object()
+        new_email = request.data.get("email", "").strip().lower()
+        code = request.data.get("code", "").strip()
+
+        # Validate the new email
+        validation_error = self._validate_new_email(user, new_email)
+        if validation_error:
+            return validation_error
+
+        if not code:
+            return Response(
+                {"error": "Verification code is required"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # Verify the magic code
+        try:
+            cache_key = f"magic_email_update_{user.id}_{new_email}"
+            cached_data = cache.get(cache_key)
+
+            if not cached_data:
+                logger.warning("Cache key not found: %s. Code may have expired or was never generated.", cache_key)
+                return Response(
+                    {"error": "Verification code has expired or is invalid"},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+            data = json.loads(cached_data)
+            stored_token = data.get("token")
+
+            if str(stored_token) != str(code):
+                return Response(
+                    {"error": "Invalid verification code"},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+        except Exception:
+            return Response(
+                {"error": "Failed to verify code. Please try again."},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # Final check: ensure email is still available (might have been taken between code generation and update)
+        if User.objects.filter(email=new_email).exclude(id=user.id).exists():
+            return Response(
+                {"error": "An account with this email already exists"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+        old_email = user.email
+        # Update the email - this updates the existing user record without creating a new user
+        user.email = new_email
+        # Reset email verification status when email is changed
+        user.is_email_verified = False
+        user.save()
+
+        # delete the cache
+        cache.delete(cache_key)
+
+        # Logout the user
+        logout(request)
+
+        # Send confirmation email to the new email address
+        send_email_update_confirmation.delay(new_email)
+        # send the email to the old email address
+        send_email_update_confirmation.delay(old_email)
+
+        # Return updated user data
+        serialized_data = UserMeSerializer(user).data
+        return Response(serialized_data, status=status.HTTP_200_OK)
+
+    def deactivate(self, request):
+        # Check all workspace user is active
+        user = self.get_object()
+
+        # Instance admin check
+        if InstanceAdmin.objects.filter(user=user).exists():
+            return Response(
+                {"error": "You cannot deactivate your account since you are an instance admin"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        projects_to_deactivate = []
+        workspaces_to_deactivate = []
+
+        projects = ProjectMember.objects.filter(member=request.user, is_active=True).annotate(
+            other_admin_exists=Count(
+                Case(
+                    When(Q(role=20, is_active=True) & ~Q(member=request.user), then=1),
+                    default=0,
+                    output_field=IntegerField(),
+                )
+            ),
+            total_members=Count("id"),
+        )
+
+        for project in projects:
+            if project.other_admin_exists > 0 or (project.total_members == 1):
+                project.is_active = False
+                projects_to_deactivate.append(project)
+            else:
+                return Response(
+                    {"error": "You cannot deactivate account as you are the only admin in some projects."},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+        workspaces = WorkspaceMember.objects.filter(member=request.user, is_active=True).annotate(
+            other_admin_exists=Count(
+                Case(
+                    When(Q(role=20, is_active=True) & ~Q(member=request.user), then=1),
+                    default=0,
+                    output_field=IntegerField(),
+                )
+            ),
+            total_members=Count("id"),
+        )
+
+        for workspace in workspaces:
+            if workspace.other_admin_exists > 0 or (workspace.total_members == 1):
+                workspace.is_active = False
+                workspaces_to_deactivate.append(workspace)
+            else:
+                return Response(
+                    {"error": "You cannot deactivate account as you are the only admin in some workspaces."},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+        ProjectMember.objects.bulk_update(projects_to_deactivate, ["is_active"], batch_size=100)
+
+        WorkspaceMember.objects.bulk_update(workspaces_to_deactivate, ["is_active"], batch_size=100)
+
+        # Delete all workspace invites
+        WorkspaceMemberInvite.objects.filter(email=user.email).delete()
+
+        # Delete all sessions
+        Session.objects.filter(user_id=request.user.id).delete()
+
+        # Profile updates
+        profile = Profile.objects.get(user=user)
+
+        # Reset onboarding
+        profile.last_workspace_id = None
+        profile.is_tour_completed = False
+        profile.is_onboarded = False
+        profile.onboarding_step = {
+            "workspace_join": False,
+            "profile_complete": False,
+            "workspace_create": False,
+            "workspace_invite": False,
+        }
+        profile.save()
+
+        # Reset password
+        user.is_password_autoset = True
+        user.set_password(uuid.uuid4().hex)
+
+        # Deactivate the user
+        user.is_active = False
+        user.last_logout_ip = user_ip(request=request)
+        user.last_logout_time = timezone.now()
+        user.save()
+
+        # Send an email to the user
+        user_deactivation_email.delay(base_host(request=request, is_app=True), user.id)
+
+        # Logout the user
+        logout(request)
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+class UserSessionEndpoint(BaseAPIView):
+    permission_classes = [AllowAny]
+
+    def get(self, request):
+        if request.user.is_authenticated:
+            user = User.objects.get(pk=request.user.id)
+            serializer = UserMeSerializer(user)
+            data = {"is_authenticated": True}
+            data["user"] = serializer.data
+            return Response(data, status=status.HTTP_200_OK)
+        else:
+            return Response({"is_authenticated": False}, status=status.HTTP_200_OK)
+
+
+class UpdateUserOnBoardedEndpoint(BaseAPIView):
+    def patch(self, request):
+        profile = Profile.objects.get(user_id=request.user.id)
+        profile.is_onboarded = request.data.get("is_onboarded", False)
+        profile.save()
+        return Response({"message": "Updated successfully"}, status=status.HTTP_200_OK)
+
+
+class UpdateUserTourCompletedEndpoint(BaseAPIView):
+    def patch(self, request):
+        profile = Profile.objects.get(user_id=request.user.id)
+        profile.is_tour_completed = request.data.get("is_tour_completed", False)
+        profile.save()
+        return Response({"message": "Updated successfully"}, status=status.HTTP_200_OK)
+
+
+class UserActivityEndpoint(BaseAPIView, BasePaginator):
+    def get(self, request):
+        queryset = IssueActivity.objects.filter(actor=request.user).select_related(
+            "actor", "workspace", "issue", "project"
+        )
+
+        return self.paginate(
+            order_by=request.GET.get("order_by", "-created_at"),
+            request=request,
+            queryset=queryset,
+            on_results=lambda issue_activities: IssueActivitySerializer(issue_activities, many=True).data,
+        )
+
+
+class AccountEndpoint(BaseAPIView):
+    def get(self, request, pk=None):
+        if pk:
+            account = Account.objects.get(pk=pk, user=request.user)
+            serializer = AccountSerializer(account)
+            return Response(serializer.data, status=status.HTTP_200_OK)
+
+        account = Account.objects.filter(user=request.user)
+        serializer = AccountSerializer(account, many=True)
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+    def delete(self, request, pk):
+        account = Account.objects.get(pk=pk, user=request.user)
+        account.delete()
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+class ProfileEndpoint(BaseAPIView):
+    @method_decorator(cache_control(private=True, max_age=12))
+    @method_decorator(vary_on_cookie)
+    def get(self, request):
+        profile = Profile.objects.get(user=request.user)
+        serializer = ProfileSerializer(profile)
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+    def patch(self, request):
+        profile = Profile.objects.get(user=request.user)
+        serializer = ProfileSerializer(profile, data=request.data, partial=True)
+        if serializer.is_valid():
+            serializer.save()
+            return Response(serializer.data, status=status.HTTP_200_OK)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

plane-src/apps/api/plane/app/views/view/base.py

@@ -0,0 +1,433 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+import copy
+
+# Django imports
+from django.db.models import (
+    Exists,
+    F,
+    Func,
+    OuterRef,
+    Q,
+    Subquery,
+    Prefetch,
+)
+from django.utils.decorators import method_decorator
+from django.views.decorators.gzip import gzip_page
+from django.db import transaction
+
+# Third party imports
+from rest_framework import status
+from rest_framework.response import Response
+
+# Module imports
+from plane.app.permissions import allow_permission, ROLE
+from plane.app.serializers import IssueViewSerializer, ViewIssueListSerializer
+from plane.db.models import (
+    Issue,
+    FileAsset,
+    IssueLink,
+    IssueView,
+    Workspace,
+    WorkspaceMember,
+    ProjectMember,
+    Project,
+    CycleIssue,
+    UserRecentVisit,
+    IssueAssignee,
+    IssueLabel,
+    ModuleIssue,
+)
+from plane.utils.issue_filters import issue_filters
+from plane.utils.order_queryset import order_issue_queryset
+from plane.bgtasks.recent_visited_task import recent_visited_task
+from .. import BaseViewSet
+from plane.db.models import UserFavorite
+from plane.utils.filters import ComplexFilterBackend
+from plane.utils.filters import IssueFilterSet
+
+
+class WorkspaceViewViewSet(BaseViewSet):
+    serializer_class = IssueViewSerializer
+    model = IssueView
+
+    def perform_create(self, serializer):
+        workspace = Workspace.objects.get(slug=self.kwargs.get("slug"))
+        serializer.save(workspace_id=workspace.id, owned_by=self.request.user)
+
+    def get_queryset(self):
+        return self.filter_queryset(
+            super()
+            .get_queryset()
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .filter(project__isnull=True)
+            .filter(Q(owned_by=self.request.user) | Q(access=1))
+            .order_by(self.request.GET.get("order_by", "-created_at"))
+            .distinct()
+        )
+
+    @allow_permission(allowed_roles=[ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], level="WORKSPACE")
+    def list(self, request, slug):
+        queryset = self.get_queryset()
+        fields = [field for field in request.GET.get("fields", "").split(",") if field]
+        if WorkspaceMember.objects.filter(workspace__slug=slug, member=request.user, role=5, is_active=True).exists():
+            queryset = queryset.filter(owned_by=request.user)
+        views = IssueViewSerializer(queryset, many=True, fields=fields if fields else None).data
+        return Response(views, status=status.HTTP_200_OK)
+
+    @allow_permission(allowed_roles=[], level="WORKSPACE", creator=True, model=IssueView)
+    def partial_update(self, request, slug, pk):
+        with transaction.atomic():
+            workspace_view = IssueView.objects.select_for_update().get(pk=pk, workspace__slug=slug)
+
+            if workspace_view.is_locked:
+                return Response({"error": "view is locked"}, status=status.HTTP_400_BAD_REQUEST)
+
+            # Only update the view if owner is updating
+            if workspace_view.owned_by_id != request.user.id:
+                return Response(
+                    {"error": "Only the owner of the view can update the view"},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+            serializer = IssueViewSerializer(workspace_view, data=request.data, partial=True)
+
+            if serializer.is_valid():
+                serializer.save()
+                return Response(serializer.data, status=status.HTTP_200_OK)
+            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    def retrieve(self, request, slug, pk):
+        issue_view = self.get_queryset().filter(pk=pk).first()
+        serializer = IssueViewSerializer(issue_view)
+        recent_visited_task.delay(
+            slug=slug,
+            project_id=None,
+            entity_name="view",
+            entity_identifier=pk,
+            user_id=request.user.id,
+        )
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+    @allow_permission(allowed_roles=[ROLE.ADMIN], level="WORKSPACE", creator=True, model=IssueView)
+    def destroy(self, request, slug, pk):
+        workspace_view = IssueView.objects.get(pk=pk, workspace__slug=slug)
+
+        workspace_member = WorkspaceMember.objects.filter(
+            workspace__slug=slug, member=request.user, role=20, is_active=True
+        )
+        if workspace_member.exists() or workspace_view.owned_by == request.user:
+            workspace_view.delete()
+            # Delete the user favorite view
+            UserFavorite.objects.filter(
+                workspace__slug=slug,
+                entity_identifier=pk,
+                project__isnull=True,
+                entity_type="view",
+            ).delete()
+        else:
+            return Response(
+                {"error": "Only admin or owner can delete the view"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+class WorkspaceViewIssuesViewSet(BaseViewSet):
+    filter_backends = (ComplexFilterBackend,)
+    filterset_class = IssueFilterSet
+
+    def _get_project_permission_filters(self):
+        """
+        Get common project permission filters for guest users and role-based access control.
+        Returns Q object for filtering issues based on user role and project settings.
+        """
+        return Q(
+            Q(
+                project__project_projectmember__role=5,
+                project__guest_view_all_features=True,
+            )
+            | Q(
+                project__project_projectmember__role=5,
+                project__guest_view_all_features=False,
+                created_by=self.request.user,
+            )
+            |
+            # For other roles (role > 5), show all issues
+            Q(project__project_projectmember__role__gt=5),
+            project__project_projectmember__member=self.request.user,
+            project__project_projectmember__is_active=True,
+        )
+
+    def apply_annotations(self, issues):
+        return (
+            issues.annotate(
+                cycle_id=Subquery(
+                    CycleIssue.objects.filter(issue=OuterRef("id"), deleted_at__isnull=True).values("cycle_id")[:1]
+                )
+            )
+            .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")
+            )
+            .annotate(
+                sub_issues_count=Issue.issue_objects.filter(parent=OuterRef("id"))
+                .order_by()
+                .annotate(count=Func(F("id"), function="Count"))
+                .values("count")
+            )
+            .prefetch_related(
+                Prefetch(
+                    "issue_assignee",
+                    queryset=IssueAssignee.objects.all(),
+                )
+            )
+            .prefetch_related(
+                Prefetch(
+                    "label_issue",
+                    queryset=IssueLabel.objects.all(),
+                )
+            )
+            .prefetch_related(
+                Prefetch(
+                    "issue_module",
+                    queryset=ModuleIssue.objects.all(),
+                )
+            )
+        )
+
+    def get_queryset(self):
+        return Issue.issue_objects.filter(workspace__slug=self.kwargs.get("slug"))
+
+    @method_decorator(gzip_page)
+    @allow_permission(allowed_roles=[ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], level="WORKSPACE")
+    def list(self, request, slug):
+        issue_queryset = self.get_queryset()
+
+        # Apply filtering from filterset
+        issue_queryset = self.filter_queryset(issue_queryset)
+
+        order_by_param = request.GET.get("order_by", "-created_at")
+
+        # Apply legacy filters
+        filters = issue_filters(request.query_params, "GET")
+        issue_queryset = issue_queryset.filter(**filters)
+
+        # Get common project permission filters
+        permission_filters = self._get_project_permission_filters()
+        # Apply project permission filters to the issue queryset
+        issue_queryset = issue_queryset.filter(permission_filters)
+
+        # Base query for the counts
+        total_issue_count_queryset = copy.deepcopy(issue_queryset)
+        total_issue_count_queryset = total_issue_count_queryset.only("id")
+
+        # Apply annotations to the issue queryset
+        issue_queryset = self.apply_annotations(issue_queryset)
+
+        # Issue queryset
+        issue_queryset, order_by_param = order_issue_queryset(
+            issue_queryset=issue_queryset, order_by_param=order_by_param
+        )
+
+        # List Paginate
+        return self.paginate(
+            order_by=order_by_param,
+            request=request,
+            queryset=issue_queryset,
+            on_results=lambda issues: ViewIssueListSerializer(issues, many=True).data,
+            total_count_queryset=total_issue_count_queryset,
+        )
+
+
+class IssueViewViewSet(BaseViewSet):
+    serializer_class = IssueViewSerializer
+    model = IssueView
+
+    def perform_create(self, serializer):
+        serializer.save(project_id=self.kwargs.get("project_id"), owned_by=self.request.user)
+
+    def get_queryset(self):
+        subquery = UserFavorite.objects.filter(
+            user=self.request.user,
+            entity_identifier=OuterRef("pk"),
+            entity_type="view",
+            project_id=self.kwargs.get("project_id"),
+            workspace__slug=self.kwargs.get("slug"),
+        )
+        return self.filter_queryset(
+            super()
+            .get_queryset()
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .filter(project_id=self.kwargs.get("project_id"))
+            .filter(
+                project__project_projectmember__member=self.request.user,
+                project__project_projectmember__is_active=True,
+                project__archived_at__isnull=True,
+            )
+            .filter(Q(owned_by=self.request.user) | Q(access=1))
+            .select_related("project")
+            .select_related("workspace")
+            .annotate(is_favorite=Exists(subquery))
+            .order_by("-is_favorite", "name")
+            .distinct()
+        )
+
+    @allow_permission(allowed_roles=[ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
+    def list(self, request, slug, project_id):
+        queryset = self.get_queryset()
+        project = Project.objects.get(id=project_id)
+        if (
+            ProjectMember.objects.filter(
+                workspace__slug=slug,
+                project_id=project_id,
+                member=request.user,
+                role=5,
+                is_active=True,
+            ).exists()
+            and not project.guest_view_all_features
+        ):
+            queryset = queryset.filter(owned_by=request.user)
+        fields = [field for field in request.GET.get("fields", "").split(",") if field]
+        views = IssueViewSerializer(queryset, many=True, fields=fields if fields else None).data
+        return Response(views, status=status.HTTP_200_OK)
+
+    @allow_permission(allowed_roles=[ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST])
+    def retrieve(self, request, slug, project_id, pk):
+        issue_view = self.get_queryset().filter(pk=pk, project_id=project_id).first()
+        project = Project.objects.get(id=project_id)
+        """
+        if the role is guest and guest_view_all_features is false and owned by is not 
+        the requesting user then dont show the view
+        """
+
+        if (
+            ProjectMember.objects.filter(
+                workspace__slug=slug,
+                project_id=project_id,
+                member=request.user,
+                role=5,
+                is_active=True,
+            ).exists()
+            and not project.guest_view_all_features
+            and not issue_view.owned_by == request.user
+        ):
+            return Response(
+                {"error": "You are not allowed to view this issue"},
+                status=status.HTTP_403_FORBIDDEN,
+            )
+
+        serializer = IssueViewSerializer(issue_view)
+        recent_visited_task.delay(
+            slug=slug,
+            project_id=project_id,
+            entity_name="view",
+            entity_identifier=pk,
+            user_id=request.user.id,
+        )
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+    @allow_permission(allowed_roles=[], creator=True, model=IssueView)
+    def partial_update(self, request, slug, project_id, pk):
+        with transaction.atomic():
+            issue_view = IssueView.objects.select_for_update().get(pk=pk, workspace__slug=slug, project_id=project_id)
+
+            if issue_view.is_locked:
+                return Response({"error": "view is locked"}, status=status.HTTP_400_BAD_REQUEST)
+
+            # Only update the view if owner is updating
+            if issue_view.owned_by_id != request.user.id:
+                return Response(
+                    {"error": "Only the owner of the view can update the view"},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+            serializer = IssueViewSerializer(issue_view, data=request.data, partial=True)
+
+            if serializer.is_valid():
+                serializer.save()
+                return Response(serializer.data, status=status.HTTP_200_OK)
+            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    @allow_permission(allowed_roles=[ROLE.ADMIN], creator=True, model=IssueView)
+    def destroy(self, request, slug, project_id, pk):
+        project_view = IssueView.objects.get(pk=pk, project_id=project_id, workspace__slug=slug)
+        if (
+            ProjectMember.objects.filter(
+                workspace__slug=slug,
+                project_id=project_id,
+                member=request.user,
+                role=20,
+                is_active=True,
+            ).exists()
+            or project_view.owned_by_id == request.user.id
+        ):
+            project_view.delete()
+            # Delete the user favorite view
+            UserFavorite.objects.filter(
+                project_id=project_id,
+                workspace__slug=slug,
+                entity_identifier=pk,
+                entity_type="view",
+            ).delete()
+            # Delete the page from recent visit
+            UserRecentVisit.objects.filter(
+                project_id=project_id,
+                workspace__slug=slug,
+                entity_identifier=pk,
+                entity_name="view",
+            ).delete(soft=False)
+        else:
+            return Response(
+                {"error": "Only admin or owner can delete the view"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+class IssueViewFavoriteViewSet(BaseViewSet):
+    model = UserFavorite
+
+    def get_queryset(self):
+        return self.filter_queryset(
+            super()
+            .get_queryset()
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .filter(user=self.request.user)
+            .select_related("view")
+        )
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
+    def create(self, request, slug, project_id):
+        _ = UserFavorite.objects.create(
+            user=request.user,
+            entity_identifier=request.data.get("view"),
+            entity_type="view",
+            project_id=project_id,
+        )
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER])
+    def destroy(self, request, slug, project_id, view_id):
+        view_favorite = UserFavorite.objects.get(
+            project=project_id,
+            user=request.user,
+            workspace__slug=slug,
+            entity_type="view",
+            entity_identifier=view_id,
+        )
+        view_favorite.delete(soft=False)
+        return Response(status=status.HTTP_204_NO_CONTENT)

plane-src/apps/api/plane/app/views/webhook/base.py

@@ -0,0 +1,126 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+# Django imports
+from django.db import IntegrityError
+
+# Third party imports
+from rest_framework import status
+from rest_framework.response import Response
+
+# Module imports
+from plane.db.models import Webhook, WebhookLog, Workspace
+from plane.db.models.webhook import generate_token
+from ..base import BaseAPIView
+from plane.app.permissions import allow_permission, ROLE
+from plane.app.serializers import WebhookSerializer, WebhookLogSerializer
+
+
+class WebhookEndpoint(BaseAPIView):
+    @allow_permission(allowed_roles=[ROLE.ADMIN], level="WORKSPACE")
+    def post(self, request, slug):
+        workspace = Workspace.objects.get(slug=slug)
+        try:
+            serializer = WebhookSerializer(data=request.data, context={"request": request})
+            if serializer.is_valid():
+                serializer.save(workspace_id=workspace.id)
+                return Response(serializer.data, status=status.HTTP_201_CREATED)
+            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+        except IntegrityError as e:
+            if "already exists" in str(e):
+                return Response(
+                    {"error": "URL already exists for the workspace"},
+                    status=status.HTTP_409_CONFLICT,
+                )
+            raise IntegrityError
+
+    @allow_permission(allowed_roles=[ROLE.ADMIN], level="WORKSPACE")
+    def get(self, request, slug, pk=None):
+        if pk is None:
+            webhooks = Webhook.objects.filter(workspace__slug=slug)
+            serializer = WebhookSerializer(
+                webhooks,
+                fields=(
+                    "id",
+                    "url",
+                    "is_active",
+                    "created_at",
+                    "updated_at",
+                    "project",
+                    "issue",
+                    "cycle",
+                    "module",
+                    "issue_comment",
+                ),
+                many=True,
+            )
+            return Response(serializer.data, status=status.HTTP_200_OK)
+        else:
+            webhook = Webhook.objects.get(workspace__slug=slug, pk=pk)
+            serializer = WebhookSerializer(
+                webhook,
+                fields=(
+                    "id",
+                    "url",
+                    "is_active",
+                    "created_at",
+                    "updated_at",
+                    "project",
+                    "issue",
+                    "cycle",
+                    "module",
+                    "issue_comment",
+                ),
+            )
+            return Response(serializer.data, status=status.HTTP_200_OK)
+
+    @allow_permission(allowed_roles=[ROLE.ADMIN], level="WORKSPACE")
+    def patch(self, request, slug, pk):
+        webhook = Webhook.objects.get(workspace__slug=slug, pk=pk)
+        serializer = WebhookSerializer(
+            webhook,
+            data=request.data,
+            context={request: request},
+            partial=True,
+            fields=(
+                "id",
+                "url",
+                "is_active",
+                "created_at",
+                "updated_at",
+                "project",
+                "issue",
+                "cycle",
+                "module",
+                "issue_comment",
+            ),
+        )
+        if serializer.is_valid():
+            serializer.save()
+            return Response(serializer.data, status=status.HTTP_200_OK)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    @allow_permission(allowed_roles=[ROLE.ADMIN], level="WORKSPACE")
+    def delete(self, request, slug, pk):
+        webhook = Webhook.objects.get(pk=pk, workspace__slug=slug)
+        webhook.delete()
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+class WebhookSecretRegenerateEndpoint(BaseAPIView):
+    @allow_permission(allowed_roles=[ROLE.ADMIN], level="WORKSPACE")
+    def post(self, request, slug, pk):
+        webhook = Webhook.objects.get(workspace__slug=slug, pk=pk)
+        webhook.secret_key = generate_token()
+        webhook.save()
+        serializer = WebhookSerializer(webhook)
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+
+class WebhookLogsEndpoint(BaseAPIView):
+    @allow_permission(allowed_roles=[ROLE.ADMIN], level="WORKSPACE")
+    def get(self, request, slug, webhook_id):
+        webhook_logs = WebhookLog.objects.filter(workspace__slug=slug, webhook=webhook_id)
+        serializer = WebhookLogSerializer(webhook_logs, many=True)
+        return Response(serializer.data, status=status.HTTP_200_OK)

plane-src/apps/api/plane/app/views/workspace/base.py

@@ -0,0 +1,420 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+# Python imports
+import csv
+import io
+import os
+from datetime import date
+import uuid
+
+from dateutil.relativedelta import relativedelta
+from django.db import IntegrityError
+from django.db.models import Count, F, Func, OuterRef, Prefetch, Q
+
+from django.db.models.fields import DateField
+from django.db.models.functions import Cast, ExtractDay, ExtractWeek
+
+
+# Django imports
+from django.http import HttpResponse
+from django.utils import timezone
+
+# Third party modules
+from rest_framework import status
+from rest_framework.response import Response
+
+from plane.app.permissions import (
+    WorkSpaceAdminPermission,
+    WorkSpaceBasePermission,
+    WorkspaceEntityPermission,
+)
+
+# Module imports
+from plane.app.serializers import WorkSpaceSerializer, WorkspaceThemeSerializer
+from plane.app.views.base import BaseAPIView, BaseViewSet
+from plane.db.models import (
+    Issue,
+    IssueActivity,
+    Workspace,
+    WorkspaceMember,
+    WorkspaceTheme,
+    Profile,
+)
+from plane.app.permissions import ROLE, allow_permission
+from plane.utils.constants import RESTRICTED_WORKSPACE_SLUGS
+from plane.license.utils.instance_value import get_configuration_value
+from plane.bgtasks.workspace_seed_task import workspace_seed
+from plane.bgtasks.event_tracking_task import track_event
+from plane.utils.url import contains_url
+from plane.utils.analytics_events import WORKSPACE_CREATED, WORKSPACE_DELETED
+from plane.utils.csv_utils import sanitize_csv_row
+
+
+class WorkSpaceViewSet(BaseViewSet):
+    model = Workspace
+    serializer_class = WorkSpaceSerializer
+    permission_classes = [WorkSpaceBasePermission]
+
+    search_fields = ["name"]
+    filterset_fields = ["owner"]
+
+    lookup_field = "slug"
+
+    def get_queryset(self):
+        member_count = (
+            WorkspaceMember.objects.filter(workspace=OuterRef("id"), member__is_bot=False, is_active=True)
+            .order_by()
+            .annotate(count=Func(F("id"), function="Count"))
+            .values("count")
+        )
+
+        return (
+            self.filter_queryset(super().get_queryset().select_related("owner"))
+            .order_by("name")
+            .filter(
+                workspace_member__member=self.request.user,
+                workspace_member__is_active=True,
+            )
+            .annotate(total_members=member_count)
+        )
+
+    def create(self, request):
+        try:
+            (DISABLE_WORKSPACE_CREATION,) = get_configuration_value(
+                [
+                    {
+                        "key": "DISABLE_WORKSPACE_CREATION",
+                        "default": os.environ.get("DISABLE_WORKSPACE_CREATION", "0"),
+                    }
+                ]
+            )
+
+            if DISABLE_WORKSPACE_CREATION == "1":
+                return Response(
+                    {"error": "Workspace creation is not allowed"},
+                    status=status.HTTP_403_FORBIDDEN,
+                )
+
+            serializer = WorkSpaceSerializer(data=request.data)
+
+            slug = request.data.get("slug", False)
+            name = request.data.get("name", False)
+
+            if not name or not slug:
+                return Response(
+                    {"error": "Both name and slug are required"},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+            if len(name) > 80 or len(slug) > 48:
+                return Response(
+                    {"error": "The maximum length for name is 80 and for slug is 48"},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+            if contains_url(name):
+                return Response(
+                    {"error": "Name cannot contain a URL"},
+                    status=status.HTTP_400_BAD_REQUEST,
+                )
+
+            if serializer.is_valid(raise_exception=True):
+                serializer.save(owner=request.user)
+                # Create Workspace member
+                _ = WorkspaceMember.objects.create(
+                    workspace_id=serializer.data["id"],
+                    member=request.user,
+                    role=20,
+                    company_role=request.data.get("company_role", ""),
+                )
+
+                # Get total members and role
+                total_members = WorkspaceMember.objects.filter(workspace_id=serializer.data["id"]).count()
+                data = serializer.data
+                data["total_members"] = total_members
+                data["role"] = 20
+
+                workspace_seed.delay(serializer.data["id"])
+
+                track_event.delay(
+                    user_id=request.user.id,
+                    event_name=WORKSPACE_CREATED,
+                    slug=data["slug"],
+                    event_properties={
+                        "user_id": request.user.id,
+                        "workspace_id": data["id"],
+                        "workspace_slug": data["slug"],
+                        "role": "owner",
+                        "workspace_name": data["name"],
+                        "created_at": data["created_at"],
+                    },
+                )
+
+                return Response(data, status=status.HTTP_201_CREATED)
+            return Response(
+                [serializer.errors[error][0] for error in serializer.errors],
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        except IntegrityError as e:
+            if "already exists" in str(e):
+                return Response(
+                    {"slug": "The workspace with the slug already exists"},
+                    status=status.HTTP_409_CONFLICT,
+                )
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], level="WORKSPACE")
+    def list(self, request, *args, **kwargs):
+        return super().list(request, *args, **kwargs)
+
+    @allow_permission([ROLE.ADMIN], level="WORKSPACE")
+    def partial_update(self, request, *args, **kwargs):
+        return super().partial_update(request, *args, **kwargs)
+
+    def remove_last_workspace_ids_from_user_settings(self, id: uuid.UUID) -> None:
+        """
+        Remove the last workspace id from the user settings
+        """
+        Profile.objects.filter(last_workspace_id=id).update(last_workspace_id=None)
+        return
+
+    @allow_permission([ROLE.ADMIN], level="WORKSPACE")
+    def destroy(self, request, *args, **kwargs):
+        # Get the workspace
+        workspace = self.get_object()
+        self.remove_last_workspace_ids_from_user_settings(workspace.id)
+        track_event.delay(
+            user_id=request.user.id,
+            event_name=WORKSPACE_DELETED,
+            slug=workspace.slug,
+            event_properties={
+                "user_id": request.user.id,
+                "workspace_id": workspace.id,
+                "workspace_slug": workspace.slug,
+                "role": "owner",
+                "workspace_name": workspace.name,
+                "deleted_at": str(timezone.now().isoformat()),
+            },
+        )
+        return super().destroy(request, *args, **kwargs)
+
+
+class UserWorkSpacesEndpoint(BaseAPIView):
+    search_fields = ["name"]
+    filterset_fields = ["owner"]
+    use_read_replica = True
+
+    def get(self, request):
+        fields = [field for field in request.GET.get("fields", "").split(",") if field]
+        member_count = (
+            WorkspaceMember.objects.filter(workspace=OuterRef("id"), member__is_bot=False, is_active=True)
+            .order_by()
+            .annotate(count=Func(F("id"), function="Count"))
+            .values("count")
+        )
+
+        role = WorkspaceMember.objects.filter(workspace=OuterRef("id"), member=request.user, is_active=True).values(
+            "role"
+        )
+
+        workspace = (
+            Workspace.objects.prefetch_related(
+                Prefetch(
+                    "workspace_member",
+                    queryset=WorkspaceMember.objects.filter(member=request.user, is_active=True),
+                )
+            )
+            .annotate(role=role, total_members=member_count)
+            .filter(workspace_member__member=request.user, workspace_member__is_active=True)
+            .distinct()
+        )
+
+        workspaces = WorkSpaceSerializer(
+            self.filter_queryset(workspace),
+            fields=fields if fields else None,
+            many=True,
+        ).data
+
+        return Response(workspaces, status=status.HTTP_200_OK)
+
+
+class WorkSpaceAvailabilityCheckEndpoint(BaseAPIView):
+    def get(self, request):
+        slug = request.GET.get("slug", False)
+
+        if not slug or slug == "":
+            return Response(
+                {"error": "Workspace Slug is required"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        workspace = Workspace.objects.filter(slug=slug).exists() or slug in RESTRICTED_WORKSPACE_SLUGS
+        return Response({"status": not workspace}, status=status.HTTP_200_OK)
+
+
+class WeekInMonth(Func):
+    function = "FLOOR"
+    template = "(((%(expressions)s - 1) / 7) + 1)::INTEGER"
+
+
+class UserWorkspaceDashboardEndpoint(BaseAPIView):
+    def get(self, request, slug):
+        issue_activities = (
+            IssueActivity.objects.filter(
+                actor=request.user,
+                workspace__slug=slug,
+                created_at__date__gte=date.today() + relativedelta(months=-3),
+            )
+            .annotate(created_date=Cast("created_at", DateField()))
+            .values("created_date")
+            .annotate(activity_count=Count("created_date"))
+            .order_by("created_date")
+        )
+
+        month = request.GET.get("month", 1)
+
+        completed_issues = (
+            Issue.issue_objects.filter(
+                assignees__in=[request.user],
+                workspace__slug=slug,
+                completed_at__month=month,
+                completed_at__isnull=False,
+            )
+            .annotate(day_of_month=ExtractDay("completed_at"))
+            .annotate(week_in_month=WeekInMonth(F("day_of_month")))
+            .values("week_in_month")
+            .annotate(completed_count=Count("id"))
+            .order_by("week_in_month")
+        )
+
+        assigned_issues = Issue.issue_objects.filter(workspace__slug=slug, assignees__in=[request.user]).count()
+
+        pending_issues_count = Issue.issue_objects.filter(
+            ~Q(state__group__in=["completed", "cancelled"]),
+            workspace__slug=slug,
+            assignees__in=[request.user],
+        ).count()
+
+        completed_issues_count = Issue.issue_objects.filter(
+            workspace__slug=slug, assignees__in=[request.user], state__group="completed"
+        ).count()
+
+        issues_due_week = (
+            Issue.issue_objects.filter(workspace__slug=slug, assignees__in=[request.user])
+            .annotate(target_week=ExtractWeek("target_date"))
+            .filter(target_week=timezone.now().date().isocalendar()[1])
+            .count()
+        )
+
+        state_distribution = (
+            Issue.issue_objects.filter(workspace__slug=slug, assignees__in=[request.user])
+            .annotate(state_group=F("state__group"))
+            .values("state_group")
+            .annotate(state_count=Count("state_group"))
+            .order_by("state_group")
+        )
+
+        overdue_issues = Issue.issue_objects.filter(
+            ~Q(state__group__in=["completed", "cancelled"]),
+            workspace__slug=slug,
+            assignees__in=[request.user],
+            target_date__lt=timezone.now(),
+            completed_at__isnull=True,
+        ).values("id", "name", "workspace__slug", "project_id", "target_date")
+
+        upcoming_issues = Issue.issue_objects.filter(
+            ~Q(state__group__in=["completed", "cancelled"]),
+            start_date__gte=timezone.now(),
+            workspace__slug=slug,
+            assignees__in=[request.user],
+            completed_at__isnull=True,
+        ).values("id", "name", "workspace__slug", "project_id", "start_date")
+
+        return Response(
+            {
+                "issue_activities": issue_activities,
+                "completed_issues": completed_issues,
+                "assigned_issues_count": assigned_issues,
+                "pending_issues_count": pending_issues_count,
+                "completed_issues_count": completed_issues_count,
+                "issues_due_week_count": issues_due_week,
+                "state_distribution": state_distribution,
+                "overdue_issues": overdue_issues,
+                "upcoming_issues": upcoming_issues,
+            },
+            status=status.HTTP_200_OK,
+        )
+
+
+class WorkspaceThemeViewSet(BaseViewSet):
+    permission_classes = [WorkSpaceAdminPermission]
+    model = WorkspaceTheme
+    serializer_class = WorkspaceThemeSerializer
+
+    def get_queryset(self):
+        return super().get_queryset().filter(workspace__slug=self.kwargs.get("slug"))
+
+    def create(self, request, slug):
+        workspace = Workspace.objects.get(slug=slug)
+        serializer = WorkspaceThemeSerializer(data=request.data)
+        if serializer.is_valid():
+            serializer.save(workspace=workspace, actor=request.user)
+            return Response(serializer.data, status=status.HTTP_201_CREATED)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+
+class ExportWorkspaceUserActivityEndpoint(BaseAPIView):
+    permission_classes = [WorkspaceEntityPermission]
+
+    def generate_csv_from_rows(self, rows):
+        """Generate CSV buffer from rows."""
+        csv_buffer = io.StringIO()
+        writer = csv.writer(csv_buffer, delimiter=",", quoting=csv.QUOTE_ALL)
+        [writer.writerow(sanitize_csv_row(row)) for row in rows]
+        csv_buffer.seek(0)
+        return csv_buffer
+
+    def post(self, request, slug, user_id):
+        if not request.data.get("date"):
+            return Response({"error": "Date is required"}, status=status.HTTP_400_BAD_REQUEST)
+
+        user_activities = IssueActivity.objects.filter(
+            ~Q(field__in=["comment", "vote", "reaction", "draft"]),
+            workspace__slug=slug,
+            created_at__date=request.data.get("date"),
+            project__project_projectmember__member=request.user,
+            project__project_projectmember__is_active=True,
+            actor_id=user_id,
+        ).select_related("actor", "workspace", "issue", "project")[:10000]
+
+        header = [
+            "Actor name",
+            "Issue ID",
+            "Project",
+            "Created at",
+            "Updated at",
+            "Action",
+            "Field",
+            "Old value",
+            "New value",
+        ]
+        rows = [
+            (
+                activity.actor.display_name,
+                f"{activity.project.identifier} - {activity.issue.sequence_id if activity.issue else ''}",
+                activity.project.name,
+                activity.created_at,
+                activity.updated_at,
+                activity.verb,
+                activity.field,
+                activity.old_value,
+                activity.new_value,
+            )
+            for activity in user_activities
+        ]
+        csv_buffer = self.generate_csv_from_rows([header] + rows)
+        response = HttpResponse(csv_buffer.getvalue(), content_type="text/csv")
+        response["Content-Disposition"] = 'attachment; filename="workspace-user-activity.csv"'
+        return response

plane-src/apps/api/plane/app/views/workspace/cycle.py

@@ -0,0 +1,104 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+# Django imports
+from django.db.models import Q, Count
+
+# Third party modules
+from rest_framework import status
+from rest_framework.response import Response
+
+# Module imports
+from plane.app.views.base import BaseAPIView
+from plane.db.models import Cycle
+from plane.app.permissions import WorkspaceViewerPermission
+from plane.app.serializers.cycle import CycleSerializer
+
+
+class WorkspaceCyclesEndpoint(BaseAPIView):
+    permission_classes = [WorkspaceViewerPermission]
+
+    def get(self, request, slug):
+        cycles = (
+            Cycle.objects.filter(workspace__slug=slug)
+            .select_related("project")
+            .select_related("workspace")
+            .select_related("owned_by")
+            .filter(archived_at__isnull=True)
+            .annotate(
+                total_issues=Count(
+                    "issue_cycle",
+                    filter=Q(
+                        issue_cycle__issue__archived_at__isnull=True,
+                        issue_cycle__issue__is_draft=False,
+                        issue_cycle__deleted_at__isnull=True,
+                        issue_cycle__issue__deleted_at__isnull=True,
+                    ),
+                )
+            )
+            .annotate(
+                completed_issues=Count(
+                    "issue_cycle__issue__state__group",
+                    filter=Q(
+                        issue_cycle__issue__state__group="completed",
+                        issue_cycle__issue__archived_at__isnull=True,
+                        issue_cycle__issue__is_draft=False,
+                        issue_cycle__issue__deleted_at__isnull=True,
+                        issue_cycle__deleted_at__isnull=True,
+                    ),
+                )
+            )
+            .annotate(
+                cancelled_issues=Count(
+                    "issue_cycle__issue__state__group",
+                    filter=Q(
+                        issue_cycle__issue__state__group="cancelled",
+                        issue_cycle__issue__archived_at__isnull=True,
+                        issue_cycle__issue__is_draft=False,
+                        issue_cycle__issue__deleted_at__isnull=True,
+                        issue_cycle__deleted_at__isnull=True,
+                    ),
+                )
+            )
+            .annotate(
+                started_issues=Count(
+                    "issue_cycle__issue__state__group",
+                    filter=Q(
+                        issue_cycle__issue__state__group="started",
+                        issue_cycle__issue__archived_at__isnull=True,
+                        issue_cycle__issue__is_draft=False,
+                        issue_cycle__issue__deleted_at__isnull=True,
+                        issue_cycle__deleted_at__isnull=True,
+                    ),
+                )
+            )
+            .annotate(
+                unstarted_issues=Count(
+                    "issue_cycle__issue__state__group",
+                    filter=Q(
+                        issue_cycle__issue__state__group="unstarted",
+                        issue_cycle__issue__archived_at__isnull=True,
+                        issue_cycle__issue__is_draft=False,
+                        issue_cycle__issue__deleted_at__isnull=True,
+                        issue_cycle__deleted_at__isnull=True,
+                    ),
+                )
+            )
+            .annotate(
+                backlog_issues=Count(
+                    "issue_cycle__issue__state__group",
+                    filter=Q(
+                        issue_cycle__issue__state__group="backlog",
+                        issue_cycle__issue__archived_at__isnull=True,
+                        issue_cycle__issue__is_draft=False,
+                        issue_cycle__issue__deleted_at__isnull=True,
+                        issue_cycle__deleted_at__isnull=True,
+                    ),
+                )
+            )
+            .order_by(self.kwargs.get("order_by", "-created_at"))
+            .distinct()
+        )
+        serializer = CycleSerializer(cycles, many=True).data
+        return Response(serializer, status=status.HTTP_200_OK)

plane-src/apps/api/plane/app/views/workspace/draft.py

@@ -0,0 +1,311 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+# Python imports
+import json
+
+# Django imports
+from django.utils import timezone
+from django.core import serializers
+from django.core.serializers.json import DjangoJSONEncoder
+from django.contrib.postgres.aggregates import ArrayAgg
+from django.contrib.postgres.fields import ArrayField
+from django.db.models import Q, UUIDField, Value, Subquery, OuterRef
+from django.db.models.functions import Coalesce
+from django.utils.decorators import method_decorator
+from django.views.decorators.gzip import gzip_page
+
+# Third Party imports
+from rest_framework import status
+from rest_framework.response import Response
+
+# Module imports
+from plane.app.permissions import allow_permission, ROLE
+from plane.app.serializers import (
+    IssueCreateSerializer,
+    DraftIssueCreateSerializer,
+    DraftIssueSerializer,
+    DraftIssueDetailSerializer,
+)
+from plane.db.models import (
+    Issue,
+    DraftIssue,
+    CycleIssue,
+    ModuleIssue,
+    DraftIssueCycle,
+    Workspace,
+    FileAsset,
+)
+from .. import BaseViewSet
+from plane.bgtasks.issue_activities_task import issue_activity
+from plane.utils.issue_filters import issue_filters
+from plane.utils.host import base_host
+
+
+class WorkspaceDraftIssueViewSet(BaseViewSet):
+    model = DraftIssue
+
+    def get_queryset(self):
+        return (
+            DraftIssue.objects.filter(workspace__slug=self.kwargs.get("slug"))
+            .select_related("workspace", "project", "state", "parent")
+            .prefetch_related("assignees", "labels", "draft_issue_module__module")
+            .annotate(
+                cycle_id=Subquery(
+                    DraftIssueCycle.objects.filter(draft_issue=OuterRef("id"), deleted_at__isnull=True).values(
+                        "cycle_id"
+                    )[:1]
+                )
+            )
+            .annotate(
+                label_ids=Coalesce(
+                    ArrayAgg(
+                        "labels__id",
+                        distinct=True,
+                        filter=Q(~Q(labels__id__isnull=True) & (Q(draft_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(draft_issue_assignee__deleted_at__isnull=True)
+                        ),
+                    ),
+                    Value([], output_field=ArrayField(UUIDField())),
+                ),
+                module_ids=Coalesce(
+                    ArrayAgg(
+                        "draft_issue_module__module_id",
+                        distinct=True,
+                        filter=Q(
+                            ~Q(draft_issue_module__module_id__isnull=True)
+                            & Q(draft_issue_module__module__archived_at__isnull=True)
+                            & Q(draft_issue_module__deleted_at__isnull=True)
+                        ),
+                    ),
+                    Value([], output_field=ArrayField(UUIDField())),
+                ),
+            )
+        ).distinct()
+
+    @method_decorator(gzip_page)
+    @allow_permission(allowed_roles=[ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], level="WORKSPACE")
+    def list(self, request, slug):
+        filters = issue_filters(request.query_params, "GET")
+        issues = self.get_queryset().filter(created_by=request.user).order_by("-created_at")
+
+        issues = issues.filter(**filters)
+        # List Paginate
+        return self.paginate(
+            request=request,
+            queryset=(issues),
+            on_results=lambda issues: DraftIssueSerializer(issues, many=True).data,
+        )
+
+    @allow_permission(allowed_roles=[ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], level="WORKSPACE")
+    def create(self, request, slug):
+        workspace = Workspace.objects.get(slug=slug)
+
+        serializer = DraftIssueCreateSerializer(
+            data=request.data,
+            context={
+                "workspace_id": workspace.id,
+                "project_id": request.data.get("project_id", None),
+            },
+        )
+        if serializer.is_valid():
+            serializer.save()
+            issue = (
+                self.get_queryset()
+                .filter(pk=serializer.data.get("id"))
+                .values(
+                    "id",
+                    "name",
+                    "state_id",
+                    "sort_order",
+                    "completed_at",
+                    "estimate_point",
+                    "priority",
+                    "start_date",
+                    "target_date",
+                    "project_id",
+                    "parent_id",
+                    "cycle_id",
+                    "module_ids",
+                    "label_ids",
+                    "assignee_ids",
+                    "created_at",
+                    "updated_at",
+                    "created_by",
+                    "updated_by",
+                    "type_id",
+                    "description_html",
+                )
+                .first()
+            )
+
+            return Response(issue, status=status.HTTP_201_CREATED)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    @allow_permission(
+        allowed_roles=[ROLE.ADMIN, ROLE.MEMBER],
+        creator=True,
+        model=Issue,
+        level="WORKSPACE",
+    )
+    def partial_update(self, request, slug, pk):
+        issue = self.get_queryset().filter(pk=pk, created_by=request.user).first()
+
+        if not issue:
+            return Response({"error": "Issue not found"}, status=status.HTTP_404_NOT_FOUND)
+
+        project_id = request.data.get("project_id", issue.project_id)
+
+        serializer = DraftIssueCreateSerializer(
+            issue,
+            data=request.data,
+            partial=True,
+            context={
+                "project_id": project_id,
+                "cycle_id": request.data.get("cycle_id", "not_provided"),
+            },
+        )
+
+        if serializer.is_valid():
+            serializer.save()
+
+            return Response(status=status.HTTP_204_NO_CONTENT)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    @allow_permission(allowed_roles=[ROLE.ADMIN], creator=True, model=Issue, level="WORKSPACE")
+    def retrieve(self, request, slug, pk=None):
+        issue = self.get_queryset().filter(pk=pk, created_by=request.user).first()
+
+        if not issue:
+            return Response(
+                {"error": "The required object does not exist."},
+                status=status.HTTP_404_NOT_FOUND,
+            )
+
+        serializer = DraftIssueDetailSerializer(issue)
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+    @allow_permission(allowed_roles=[ROLE.ADMIN], creator=True, model=DraftIssue, level="WORKSPACE")
+    def destroy(self, request, slug, pk=None):
+        draft_issue = DraftIssue.objects.get(workspace__slug=slug, pk=pk)
+        draft_issue.delete()
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+    @allow_permission(allowed_roles=[ROLE.ADMIN, ROLE.MEMBER], level="WORKSPACE")
+    def create_draft_to_issue(self, request, slug, draft_id):
+        draft_issue = self.get_queryset().filter(pk=draft_id).first()
+
+        if not draft_issue.project_id:
+            return Response(
+                {"error": "Project is required to create an issue."},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        serializer = IssueCreateSerializer(
+            data=request.data,
+            context={
+                "project_id": draft_issue.project_id,
+                "workspace_id": draft_issue.project.workspace_id,
+                "default_assignee_id": draft_issue.project.default_assignee_id,
+            },
+        )
+
+        if serializer.is_valid():
+            serializer.save()
+
+            issue_activity.delay(
+                type="issue.activity.created",
+                requested_data=json.dumps(self.request.data, cls=DjangoJSONEncoder),
+                actor_id=str(request.user.id),
+                issue_id=str(serializer.data.get("id", None)),
+                project_id=str(draft_issue.project_id),
+                current_instance=None,
+                epoch=int(timezone.now().timestamp()),
+                notification=True,
+                origin=base_host(request=request, is_app=True),
+            )
+
+            if request.data.get("cycle_id", None):
+                created_records = CycleIssue.objects.create(
+                    cycle_id=request.data.get("cycle_id", None),
+                    issue_id=serializer.data.get("id", None),
+                    project_id=draft_issue.project_id,
+                    workspace_id=draft_issue.workspace_id,
+                    created_by_id=draft_issue.created_by_id,
+                    updated_by_id=draft_issue.updated_by_id,
+                )
+                # Capture Issue Activity
+                issue_activity.delay(
+                    type="cycle.activity.created",
+                    requested_data=None,
+                    actor_id=str(self.request.user.id),
+                    issue_id=None,
+                    project_id=str(self.kwargs.get("project_id", None)),
+                    current_instance=json.dumps(
+                        {
+                            "updated_cycle_issues": None,
+                            "created_cycle_issues": serializers.serialize("json", [created_records]),
+                        }
+                    ),
+                    epoch=int(timezone.now().timestamp()),
+                    notification=True,
+                    origin=base_host(request=request, is_app=True),
+                )
+
+            if request.data.get("module_ids", []):
+                # bulk create the module
+                ModuleIssue.objects.bulk_create(
+                    [
+                        ModuleIssue(
+                            module_id=module,
+                            issue_id=serializer.data.get("id", None),
+                            workspace_id=draft_issue.workspace_id,
+                            project_id=draft_issue.project_id,
+                            created_by_id=draft_issue.created_by_id,
+                            updated_by_id=draft_issue.updated_by_id,
+                        )
+                        for module in request.data.get("module_ids", [])
+                    ],
+                    batch_size=10,
+                )
+                # Update the activity
+                _ = [
+                    issue_activity.delay(
+                        type="module.activity.created",
+                        requested_data=json.dumps({"module_id": str(module)}),
+                        actor_id=str(request.user.id),
+                        issue_id=serializer.data.get("id", None),
+                        project_id=draft_issue.project_id,
+                        current_instance=None,
+                        epoch=int(timezone.now().timestamp()),
+                        notification=True,
+                        origin=base_host(request=request, is_app=True),
+                    )
+                    for module in request.data.get("module_ids", [])
+                ]
+
+            # Update file assets
+            file_assets = FileAsset.objects.filter(draft_issue_id=draft_id)
+            file_assets.update(
+                issue_id=serializer.data.get("id", None),
+                entity_type=FileAsset.EntityTypeContext.ISSUE_DESCRIPTION,
+                draft_issue_id=None,
+            )
+
+            # delete the draft issue
+            draft_issue.delete()
+
+            return Response(serializer.data, status=status.HTTP_201_CREATED)
+
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

plane-src/apps/api/plane/app/views/workspace/estimate.py

@@ -0,0 +1,33 @@
+# Copyright (c) 2023-present Plane Software, Inc. and contributors
+# SPDX-License-Identifier: AGPL-3.0-only
+# See the LICENSE file for details.
+
+# Third party modules
+from rest_framework import status
+from rest_framework.response import Response
+
+# Module imports
+from plane.app.permissions import WorkspaceEntityPermission
+from plane.app.serializers import WorkspaceEstimateSerializer
+from plane.app.views.base import BaseAPIView
+from plane.db.models import Estimate, Project
+from plane.utils.cache import cache_response
+
+
+class WorkspaceEstimatesEndpoint(BaseAPIView):
+    permission_classes = [WorkspaceEntityPermission]
+    use_read_replica = True
+
+    @cache_response(60 * 60 * 2)
+    def get(self, request, slug):
+        estimate_ids = Project.objects.filter(workspace__slug=slug, estimate__isnull=False).values_list(
+            "estimate_id", flat=True
+        )
+        estimates = (
+            Estimate.objects.filter(pk__in=estimate_ids, workspace__slug=slug)
+            .prefetch_related("points")
+            .select_related("workspace", "project")
+        )
+
+        serializer = WorkspaceEstimateSerializer(estimates, many=True)
+        return Response(serializer.data, status=status.HTTP_200_OK)