base

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)

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

@@ -0,0 +1,97 @@
+# 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
+
+# Django modules
+from django.db.models import Q
+from django.db import IntegrityError
+
+# Module imports
+from plane.app.views.base import BaseAPIView
+from plane.db.models import UserFavorite, Workspace
+from plane.app.serializers import UserFavoriteSerializer
+from plane.app.permissions import allow_permission, ROLE
+
+
+class WorkspaceFavoriteEndpoint(BaseAPIView):
+    use_read_replica = True
+
+    @allow_permission(allowed_roles=[ROLE.ADMIN, ROLE.MEMBER], level="WORKSPACE")
+    def get(self, request, slug):
+        # the second filter is to check if the user is a member of the project
+        favorites = UserFavorite.objects.filter(user=request.user, workspace__slug=slug, parent__isnull=True).filter(
+            Q(project__isnull=True) & ~Q(entity_type="page")
+            | (
+                Q(project__isnull=False)
+                & Q(project__project_projectmember__member=request.user)
+                & Q(project__project_projectmember__is_active=True)
+            )
+        )
+        serializer = UserFavoriteSerializer(favorites, many=True)
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+    @allow_permission(allowed_roles=[ROLE.ADMIN, ROLE.MEMBER], level="WORKSPACE")
+    def post(self, request, slug):
+        try:
+            workspace = Workspace.objects.get(slug=slug)
+
+            # If the favorite exists return
+            if request.data.get("entity_identifier"):
+                user_favorites = UserFavorite.objects.filter(
+                    workspace=workspace,
+                    user_id=request.user.id,
+                    entity_type=request.data.get("entity_type"),
+                    entity_identifier=request.data.get("entity_identifier"),
+                ).first()
+
+                # If the favorite exists return
+                if user_favorites:
+                    serializer = UserFavoriteSerializer(user_favorites)
+                    return Response(serializer.data, status=status.HTTP_200_OK)
+
+            # else create a new favorite
+            serializer = UserFavoriteSerializer(data=request.data)
+            if serializer.is_valid():
+                serializer.save(
+                    user_id=request.user.id,
+                    workspace=workspace,
+                    project_id=request.data.get("project_id", None),
+                )
+                return Response(serializer.data, status=status.HTTP_200_OK)
+            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+        except IntegrityError:
+            return Response({"error": "Favorite already exists"}, status=status.HTTP_400_BAD_REQUEST)
+
+    @allow_permission(allowed_roles=[ROLE.ADMIN, ROLE.MEMBER], level="WORKSPACE")
+    def patch(self, request, slug, favorite_id):
+        favorite = UserFavorite.objects.get(user=request.user, workspace__slug=slug, pk=favorite_id)
+        serializer = UserFavoriteSerializer(favorite, 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, ROLE.MEMBER], level="WORKSPACE")
+    def delete(self, request, slug, favorite_id):
+        favorite = UserFavorite.objects.get(user=request.user, workspace__slug=slug, pk=favorite_id)
+        favorite.delete(soft=False)
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+class WorkspaceFavoriteGroupEndpoint(BaseAPIView):
+    @allow_permission(allowed_roles=[ROLE.ADMIN, ROLE.MEMBER], level="WORKSPACE")
+    def get(self, request, slug, favorite_id):
+        favorites = UserFavorite.objects.filter(user=request.user, workspace__slug=slug, parent_id=favorite_id).filter(
+            Q(project__isnull=True)
+            | (
+                Q(project__isnull=False)
+                & Q(project__project_projectmember__member=request.user)
+                & Q(project__project_projectmember__is_active=True)
+            )
+        )
+        serializer = UserFavoriteSerializer(favorites, many=True)
+        return Response(serializer.data, status=status.HTTP_200_OK)

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

@@ -0,0 +1,79 @@
+# 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 BaseAPIView
+from plane.db.models.workspace import WorkspaceHomePreference
+from plane.app.permissions import allow_permission, ROLE
+from plane.db.models import Workspace
+from plane.app.serializers.workspace import WorkspaceHomePreferenceSerializer
+
+# Third party imports
+from rest_framework.response import Response
+from rest_framework import status
+
+
+class WorkspaceHomePreferenceViewSet(BaseAPIView):
+    model = WorkspaceHomePreference
+
+    def get_serializer_class(self):
+        return WorkspaceHomePreferenceSerializer
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], level="WORKSPACE")
+    def get(self, request, slug):
+        workspace = Workspace.objects.get(slug=slug)
+
+        get_preference = WorkspaceHomePreference.objects.filter(user=request.user, workspace_id=workspace.id)
+
+        create_preference_keys = []
+
+        keys = [
+            key
+            for key, _ in WorkspaceHomePreference.HomeWidgetKeys.choices
+            if key not in ["quick_tutorial", "new_at_plane"]
+        ]
+
+        sort_order_counter = 1
+
+        for preference in keys:
+            if preference not in get_preference.values_list("key", flat=True):
+                create_preference_keys.append(preference)
+
+                sort_order = 1000 - sort_order_counter
+
+                preference = WorkspaceHomePreference.objects.bulk_create(
+                    [
+                        WorkspaceHomePreference(
+                            key=key,
+                            user=request.user,
+                            workspace=workspace,
+                            sort_order=sort_order,
+                        )
+                        for key in create_preference_keys
+                    ],
+                    batch_size=10,
+                    ignore_conflicts=True,
+                )
+                sort_order_counter += 1
+
+        preference = WorkspaceHomePreference.objects.filter(user=request.user, workspace_id=workspace.id)
+
+        return Response(
+            preference.values("key", "is_enabled", "config", "sort_order"),
+            status=status.HTTP_200_OK,
+        )
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], level="WORKSPACE")
+    def patch(self, request, slug, key):
+        preference = WorkspaceHomePreference.objects.filter(key=key, workspace__slug=slug, user=request.user).first()
+
+        if preference:
+            serializer = WorkspaceHomePreferenceSerializer(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)
+
+        return Response({"detail": "Preference not found"}, status=status.HTTP_400_BAD_REQUEST)

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

@@ -0,0 +1,305 @@
+# 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 datetime import datetime
+
+import jwt
+
+# Django imports
+from django.conf import settings
+from django.core.exceptions import ValidationError
+from django.core.validators import validate_email
+from django.utils import timezone
+
+# Third party modules
+from rest_framework import status
+from rest_framework.permissions import AllowAny
+from rest_framework.response import Response
+
+# Module imports
+from plane.app.permissions import WorkSpaceAdminPermission
+from plane.app.serializers import (
+    WorkSpaceMemberInviteSerializer,
+    WorkSpaceMemberSerializer,
+)
+from plane.app.views.base import BaseAPIView
+from plane.bgtasks.event_tracking_task import track_event
+from plane.bgtasks.workspace_invitation_task import workspace_invitation
+from plane.db.models import User, Workspace, WorkspaceMember, WorkspaceMemberInvite
+from plane.utils.cache import invalidate_cache, invalidate_cache_directly
+from plane.utils.host import base_host
+from plane.utils.analytics_events import USER_JOINED_WORKSPACE, USER_INVITED_TO_WORKSPACE
+from .. import BaseViewSet
+
+
+class WorkspaceInvitationsViewset(BaseViewSet):
+    """Endpoint for creating, listing and  deleting workspaces"""
+
+    serializer_class = WorkSpaceMemberInviteSerializer
+    model = WorkspaceMemberInvite
+
+    permission_classes = [WorkSpaceAdminPermission]
+
+    def get_queryset(self):
+        return self.filter_queryset(
+            super()
+            .get_queryset()
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .select_related("workspace", "workspace__owner", "created_by")
+        )
+
+    def create(self, request, slug):
+        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)
+
+        # check for role level of the requesting user
+        requesting_user = WorkspaceMember.objects.get(workspace__slug=slug, member=request.user, is_active=True)
+
+        # Check if any invited user has an higher role
+        if len([email for email in emails if int(email.get("role", 5)) > requesting_user.role]):
+            return Response(
+                {"error": "You cannot invite a user with higher role"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # Get the workspace object
+        workspace = Workspace.objects.get(slug=slug)
+
+        # Check if user is already a member of workspace
+        workspace_members = WorkspaceMember.objects.filter(
+            workspace_id=workspace.id,
+            member__email__in=[email.get("email") for email in emails],
+            is_active=True,
+        ).select_related("member", "member__avatar_asset")
+
+        if workspace_members:
+            return Response(
+                {
+                    "error": "Some users are already member of workspace",
+                    "workspace_users": WorkSpaceMemberSerializer(workspace_members, many=True).data,
+                },
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        workspace_invitations = []
+        for email in emails:
+            try:
+                validate_email(email.get("email"))
+                workspace_invitations.append(
+                    WorkspaceMemberInvite(
+                        email=email.get("email").strip().lower(),
+                        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
+        workspace_invitations = WorkspaceMemberInvite.objects.bulk_create(
+            workspace_invitations, batch_size=10, ignore_conflicts=True
+        )
+
+        current_site = base_host(request=request, is_app=True)
+
+        # Send invitations
+        for invitation in workspace_invitations:
+            workspace_invitation.delay(
+                invitation.email,
+                workspace.id,
+                invitation.token,
+                current_site,
+                request.user.email,
+            )
+            track_event.delay(
+                user_id=request.user.id,
+                event_name=USER_INVITED_TO_WORKSPACE,
+                slug=slug,
+                event_properties={
+                    "user_id": request.user.id,
+                    "workspace_id": workspace.id,
+                    "workspace_slug": workspace.slug,
+                    "invitee_role": invitation.role,
+                    "invited_at": str(timezone.now()),
+                    "invitee_email": invitation.email,
+                },
+            )
+
+        return Response({"message": "Emails sent successfully"}, status=status.HTTP_200_OK)
+
+    def destroy(self, request, slug, pk):
+        workspace_member_invite = WorkspaceMemberInvite.objects.get(pk=pk, workspace__slug=slug)
+        workspace_member_invite.delete()
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+class WorkspaceJoinEndpoint(BaseAPIView):
+    permission_classes = [AllowAny]
+    """Invitation response endpoint the user can respond to the invitation"""
+
+    @invalidate_cache(path="/api/workspaces/", user=False)
+    @invalidate_cache(path="/api/users/me/workspaces/", multiple=True)
+    @invalidate_cache(
+        path="/api/workspaces/:slug/members/",
+        user=False,
+        multiple=True,
+        url_params=True,
+    )
+    @invalidate_cache(path="/api/users/me/settings/", multiple=True)
+    def post(self, request, slug, pk):
+        workspace_invite = WorkspaceMemberInvite.objects.get(pk=pk, workspace__slug=slug)
+
+        token = request.data.get("token", "")
+
+        # Validate the token to verify the user received the invitation email
+        if not token or workspace_invite.token != token:
+            return Response(
+                {"error": "You do not have permission to join the workspace"},
+                status=status.HTTP_403_FORBIDDEN,
+            )
+
+        # If already responded then return error
+        if workspace_invite.responded_at is None:
+            workspace_invite.accepted = request.data.get("accepted", False)
+            workspace_invite.responded_at = timezone.now()
+            workspace_invite.save()
+
+            if workspace_invite.accepted:
+                # Check if the user created account after invitation
+                user = User.objects.filter(email=workspace_invite.email).first()
+
+                # If the user is present then create the workspace member
+                if user is not None:
+                    # Check if the user was already a member of workspace then activate the user
+                    workspace_member = WorkspaceMember.objects.filter(
+                        workspace=workspace_invite.workspace, member=user
+                    ).first()
+                    if workspace_member is not None:
+                        workspace_member.is_active = True
+                        workspace_member.role = workspace_invite.role
+                        workspace_member.save()
+                    else:
+                        # Create a Workspace
+                        _ = WorkspaceMember.objects.create(
+                            workspace=workspace_invite.workspace,
+                            member=user,
+                            role=workspace_invite.role,
+                        )
+
+                    # Set the user last_workspace_id to the accepted workspace
+                    user.last_workspace_id = workspace_invite.workspace.id
+                    user.save()
+                    track_event.delay(
+                        user_id=user.id,
+                        event_name=USER_JOINED_WORKSPACE,
+                        slug=slug,
+                        event_properties={
+                            "user_id": user.id,
+                            "workspace_id": workspace_invite.workspace.id,
+                            "workspace_slug": workspace_invite.workspace.slug,
+                            "role": workspace_invite.role,
+                            "joined_at": str(timezone.now()),
+                        },
+                    )
+
+                    # Delete the invitation
+                    workspace_invite.delete()
+
+                return Response(
+                    {"message": "Workspace Invitation Accepted"},
+                    status=status.HTTP_200_OK,
+                )
+
+            # Workspace invitation rejected
+            return Response(
+                {"message": "Workspace 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, pk):
+        workspace_invitation = WorkspaceMemberInvite.objects.get(workspace__slug=slug, pk=pk)
+        serializer = WorkSpaceMemberInviteSerializer(workspace_invitation)
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+
+class UserWorkspaceInvitationsViewSet(BaseViewSet):
+    serializer_class = WorkSpaceMemberInviteSerializer
+    model = WorkspaceMemberInvite
+
+    def get_queryset(self):
+        return self.filter_queryset(
+            super().get_queryset().filter(email=self.request.user.email).select_related("workspace")
+        )
+
+    @invalidate_cache(path="/api/workspaces/", user=False)
+    @invalidate_cache(path="/api/users/me/workspaces/", multiple=True)
+    def create(self, request):
+        invitations = request.data.get("invitations", [])
+        workspace_invitations = WorkspaceMemberInvite.objects.filter(
+            pk__in=invitations, email=request.user.email
+        ).order_by("-created_at")
+
+        # If the user is already a member of workspace and was deactivated then activate the user
+        for invitation in workspace_invitations:
+            invalidate_cache_directly(
+                path=f"/api/workspaces/{invitation.workspace.slug}/members/",
+                user=False,
+                request=request,
+                multiple=True,
+            )
+            # Update the WorkspaceMember for this specific invitation
+            WorkspaceMember.objects.filter(workspace_id=invitation.workspace_id, member=request.user).update(
+                is_active=True, role=invitation.role
+            )
+
+            # Track event
+            track_event.delay(
+                user_id=request.user.id,
+                event_name=USER_JOINED_WORKSPACE,
+                slug=invitation.workspace.slug,
+                event_properties={
+                    "user_id": request.user.id,
+                    "workspace_id": invitation.workspace.id,
+                    "workspace_slug": invitation.workspace.slug,
+                    "role": invitation.role,
+                    "joined_at": str(timezone.now()),
+                },
+            )
+
+        # Bulk create the user for all the workspaces
+        WorkspaceMember.objects.bulk_create(
+            [
+                WorkspaceMember(
+                    workspace=invitation.workspace,
+                    member=request.user,
+                    role=invitation.role,
+                    created_by=request.user,
+                )
+                for invitation in workspace_invitations
+            ],
+            ignore_conflicts=True,
+        )
+
+        # Delete joined workspace invites
+        workspace_invitations.delete()
+
+        return Response(status=status.HTTP_204_NO_CONTENT)

plane-src/apps/api/plane/app/views/workspace/label.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.
+
+# Third party modules
+from rest_framework import status
+from rest_framework.response import Response
+
+# Module imports
+from plane.app.serializers import LabelSerializer
+from plane.app.views.base import BaseAPIView
+from plane.db.models import Label
+from plane.app.permissions import WorkspaceViewerPermission
+from plane.utils.cache import cache_response
+
+
+class WorkspaceLabelsEndpoint(BaseAPIView):
+    permission_classes = [WorkspaceViewerPermission]
+    use_read_replica = True
+
+    @cache_response(60 * 60 * 2)
+    def get(self, request, slug):
+        labels = Label.objects.filter(
+            workspace__slug=slug,
+            project__project_projectmember__member=request.user,
+            project__project_projectmember__is_active=True,
+            project__archived_at__isnull=True,
+        )
+        serializer = LabelSerializer(labels, many=True).data
+        return Response(serializer, status=status.HTTP_200_OK)

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

@@ -0,0 +1,266 @@
+# 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, Q, OuterRef, Subquery, IntegerField
+from django.utils import timezone
+from django.db.models.functions import Coalesce
+
+# Third party modules
+from rest_framework import status
+from rest_framework.response import Response
+
+from plane.app.permissions import WorkspaceEntityPermission, allow_permission, ROLE
+
+# Module imports
+from plane.app.serializers import (
+    ProjectMemberRoleSerializer,
+    WorkspaceMemberAdminSerializer,
+    WorkspaceMemberMeSerializer,
+    WorkSpaceMemberSerializer,
+)
+from plane.app.views.base import BaseAPIView
+from plane.db.models import Project, ProjectMember, WorkspaceMember, DraftIssue
+from plane.utils.cache import invalidate_cache
+
+from .. import BaseViewSet
+
+
+class WorkSpaceMemberViewSet(BaseViewSet):
+    serializer_class = WorkspaceMemberAdminSerializer
+    model = WorkspaceMember
+
+    search_fields = ["member__display_name", "member__first_name"]
+    use_read_replica = True
+
+    def get_queryset(self):
+        return self.filter_queryset(
+            super()
+            .get_queryset()
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .select_related("member", "member__avatar_asset")
+        )
+
+    @allow_permission(allowed_roles=[ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], level="WORKSPACE")
+    def list(self, request, slug):
+        workspace_member = WorkspaceMember.objects.get(member=request.user, workspace__slug=slug, is_active=True)
+
+        # Get all active workspace members
+        workspace_members = self.get_queryset()
+        if workspace_member.role > 5:
+            serializer = WorkspaceMemberAdminSerializer(workspace_members, fields=("id", "member", "role"), many=True)
+        else:
+            serializer = WorkSpaceMemberSerializer(workspace_members, fields=("id", "member", "role"), many=True)
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+    @allow_permission(allowed_roles=[ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], level="WORKSPACE")
+    def retrieve(self, request, slug, pk):
+        workspace_member = WorkspaceMember.objects.get(member=request.user, workspace__slug=slug, is_active=True)
+
+        try:
+            # Get the specific workspace member by pk
+            member = self.get_queryset().get(pk=pk)
+        except WorkspaceMember.DoesNotExist:
+            return Response(
+                {"error": "Workspace member not found"},
+                status=status.HTTP_404_NOT_FOUND,
+            )
+
+        if workspace_member.role > ROLE.GUEST.value:
+            serializer = WorkspaceMemberAdminSerializer(member, fields=("id", "member", "role"))
+        else:
+            serializer = WorkSpaceMemberSerializer(member, fields=("id", "member", "role"))
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+    @allow_permission(allowed_roles=[ROLE.ADMIN], level="WORKSPACE")
+    def partial_update(self, request, slug, pk):
+        workspace_member = WorkspaceMember.objects.get(
+            pk=pk, workspace__slug=slug, member__is_bot=False, is_active=True
+        )
+        if request.user.id == workspace_member.member_id:
+            return Response(
+                {"error": "You cannot update your own role"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # If a user is moved to a guest role he can't have any other role in projects
+        if "role" in request.data and int(request.data.get("role")) == 5:
+            ProjectMember.objects.filter(workspace__slug=slug, member_id=workspace_member.member_id).update(role=5)
+
+        serializer = WorkSpaceMemberSerializer(workspace_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(allowed_roles=[ROLE.ADMIN], level="WORKSPACE")
+    def destroy(self, request, slug, pk):
+        # Check the user role who is deleting the user
+        workspace_member = WorkspaceMember.objects.get(
+            workspace__slug=slug, pk=pk, member__is_bot=False, is_active=True
+        )
+
+        # check requesting user role
+        requesting_workspace_member = WorkspaceMember.objects.get(
+            workspace__slug=slug, member=request.user, is_active=True
+        )
+
+        if str(workspace_member.id) == str(requesting_workspace_member.id):
+            return Response(
+                {"error": "You cannot remove yourself from the workspace. Please use leave workspace"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        if requesting_workspace_member.role < workspace_member.role:
+            return Response(
+                {"error": "You cannot remove a user having role higher than you"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        if (
+            Project.objects.annotate(
+                total_members=Count("project_projectmember"),
+                member_with_role=Count(
+                    "project_projectmember",
+                    filter=Q(
+                        project_projectmember__member_id=workspace_member.id,
+                        project_projectmember__role=20,
+                    ),
+                ),
+            )
+            .filter(total_members=1, member_with_role=1, workspace__slug=slug)
+            .exists()
+        ):
+            return Response(
+                {
+                    "error": "User is a part of some projects where they are the only admin, they should either leave that project or promote another user to admin."  # noqa: E501
+                },
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # Deactivate the users from the projects where the user is part of
+        _ = ProjectMember.objects.filter(
+            workspace__slug=slug, member_id=workspace_member.member_id, is_active=True
+        ).update(is_active=False, updated_at=timezone.now())
+
+        workspace_member.is_active = False
+        workspace_member.save()
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+    @invalidate_cache(
+        path="/api/workspaces/:slug/members/",
+        url_params=True,
+        user=False,
+        multiple=True,
+    )
+    @invalidate_cache(path="/api/users/me/settings/")
+    @invalidate_cache(path="api/users/me/workspaces/", user=False, multiple=True)
+    @allow_permission(allowed_roles=[ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], level="WORKSPACE")
+    def leave(self, request, slug):
+        workspace_member = WorkspaceMember.objects.get(workspace__slug=slug, member=request.user, is_active=True)
+
+        # Check if the leaving user is the only admin of the workspace
+        if (
+            workspace_member.role == 20
+            and not WorkspaceMember.objects.filter(workspace__slug=slug, role=20, is_active=True).count() > 1
+        ):
+            return Response(
+                {
+                    "error": "You cannot leave the workspace as you are the only admin of the workspace you will have to either delete the workspace or promote another user to admin."  # noqa: E501
+                },
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        if (
+            Project.objects.annotate(
+                total_members=Count("project_projectmember"),
+                member_with_role=Count(
+                    "project_projectmember",
+                    filter=Q(
+                        project_projectmember__member_id=request.user.id,
+                        project_projectmember__role=20,
+                    ),
+                ),
+            )
+            .filter(total_members=1, member_with_role=1, workspace__slug=slug)
+            .exists()
+        ):
+            return Response(
+                {
+                    "error": "You are a part of some projects where you are the only admin, you should either leave the project or promote another user to admin."  # noqa: E501
+                },
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # # Deactivate the users from the projects where the user is part of
+        _ = ProjectMember.objects.filter(
+            workspace__slug=slug, member_id=workspace_member.member_id, is_active=True
+        ).update(is_active=False, updated_at=timezone.now())
+
+        # # Deactivate the user
+        workspace_member.is_active = False
+        workspace_member.save()
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+class WorkspaceMemberUserViewsEndpoint(BaseAPIView):
+    def post(self, request, slug):
+        workspace_member = WorkspaceMember.objects.get(workspace__slug=slug, member=request.user, is_active=True)
+        workspace_member.view_props = request.data.get("view_props", {})
+        workspace_member.save()
+
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+
+class WorkspaceMemberUserEndpoint(BaseAPIView):
+    use_read_replica = True
+
+    def get(self, request, slug):
+        draft_issue_count = (
+            DraftIssue.objects.filter(created_by=request.user, workspace_id=OuterRef("workspace_id"))
+            .values("workspace_id")
+            .annotate(count=Count("id"))
+            .values("count")
+        )
+
+        workspace_member = (
+            WorkspaceMember.objects.filter(member=request.user, workspace__slug=slug, is_active=True)
+            .annotate(draft_issue_count=Coalesce(Subquery(draft_issue_count, output_field=IntegerField()), 0))
+            .first()
+        )
+        serializer = WorkspaceMemberMeSerializer(workspace_member)
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+
+class WorkspaceProjectMemberEndpoint(BaseAPIView):
+    serializer_class = ProjectMemberRoleSerializer
+    model = ProjectMember
+
+    permission_classes = [WorkspaceEntityPermission]
+
+    def get(self, request, slug):
+        # Fetch all project IDs where the user is involved
+        project_ids = (
+            ProjectMember.objects.filter(member=request.user, is_active=True)
+            .values_list("project_id", flat=True)
+            .distinct()
+        )
+
+        # Get all the project members in which the user is involved
+        project_members = ProjectMember.objects.filter(
+            workspace__slug=slug, project_id__in=project_ids, is_active=True
+        ).select_related("project", "member", "workspace")
+        project_members = ProjectMemberRoleSerializer(project_members, many=True).data
+
+        project_members_dict = dict()
+
+        # Construct a dictionary with project_id as key and project_members as value
+        for project_member in project_members:
+            project_id = project_member.pop("project")
+            if str(project_id) not in project_members_dict:
+                project_members_dict[str(project_id)] = []
+            project_members_dict[str(project_id)].append(project_member)
+
+        return Response(project_members_dict, status=status.HTTP_200_OK)

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

@@ -0,0 +1,111 @@
+# 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 Prefetch, 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 Module, ModuleLink
+from plane.app.permissions import WorkspaceViewerPermission
+from plane.app.serializers.module import ModuleSerializer
+
+
+class WorkspaceModulesEndpoint(BaseAPIView):
+    permission_classes = [WorkspaceViewerPermission]
+
+    def get(self, request, slug):
+        modules = (
+            Module.objects.filter(workspace__slug=slug)
+            .select_related("project")
+            .select_related("workspace")
+            .select_related("lead")
+            .prefetch_related("members")
+            .filter(archived_at__isnull=True)
+            .prefetch_related(
+                Prefetch(
+                    "link_module",
+                    queryset=ModuleLink.objects.select_related("module", "created_by"),
+                )
+            )
+            .annotate(
+                total_issues=Count(
+                    "issue_module",
+                    filter=Q(
+                        issue_module__issue__archived_at__isnull=True,
+                        issue_module__issue__is_draft=False,
+                        issue_module__deleted_at__isnull=True,
+                    ),
+                    distinct=True,
+                )
+            )
+            .annotate(
+                completed_issues=Count(
+                    "issue_module",
+                    filter=Q(
+                        issue_module__issue__state__group="completed",
+                        issue_module__issue__archived_at__isnull=True,
+                        issue_module__issue__is_draft=False,
+                        issue_module__deleted_at__isnull=True,
+                    ),
+                    distinct=True,
+                )
+            )
+            .annotate(
+                cancelled_issues=Count(
+                    "issue_module",
+                    filter=Q(
+                        issue_module__issue__state__group="cancelled",
+                        issue_module__issue__archived_at__isnull=True,
+                        issue_module__issue__is_draft=False,
+                        issue_module__deleted_at__isnull=True,
+                    ),
+                    distinct=True,
+                )
+            )
+            .annotate(
+                started_issues=Count(
+                    "issue_module",
+                    filter=Q(
+                        issue_module__issue__state__group="started",
+                        issue_module__issue__archived_at__isnull=True,
+                        issue_module__issue__is_draft=False,
+                        issue_module__deleted_at__isnull=True,
+                    ),
+                    distinct=True,
+                )
+            )
+            .annotate(
+                unstarted_issues=Count(
+                    "issue_module",
+                    filter=Q(
+                        issue_module__issue__state__group="unstarted",
+                        issue_module__issue__archived_at__isnull=True,
+                        issue_module__issue__is_draft=False,
+                        issue_module__deleted_at__isnull=True,
+                    ),
+                    distinct=True,
+                )
+            )
+            .annotate(
+                backlog_issues=Count(
+                    "issue_module",
+                    filter=Q(
+                        issue_module__issue__state__group="backlog",
+                        issue_module__issue__archived_at__isnull=True,
+                        issue_module__issue__is_draft=False,
+                        issue_module__deleted_at__isnull=True,
+                    ),
+                    distinct=True,
+                )
+            )
+            .order_by(self.kwargs.get("order_by", "-created_at"))
+        )
+
+        serializer = ModuleSerializer(modules, many=True).data
+        return Response(serializer, status=status.HTTP_200_OK)

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

@@ -0,0 +1,65 @@
+# 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 WorkspaceUserLink, Workspace
+from plane.app.serializers import WorkspaceUserLinkSerializer
+from ..base import BaseViewSet
+from plane.app.permissions import allow_permission, ROLE
+
+
+class QuickLinkViewSet(BaseViewSet):
+    model = WorkspaceUserLink
+    use_read_replica = True
+
+    def get_serializer_class(self):
+        return WorkspaceUserLinkSerializer
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], level="WORKSPACE")
+    def create(self, request, slug):
+        workspace = Workspace.objects.get(slug=slug)
+        serializer = WorkspaceUserLinkSerializer(data=request.data)
+
+        if serializer.is_valid():
+            serializer.save(workspace_id=workspace.id, owner_id=request.user.id)
+            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], level="WORKSPACE")
+    def partial_update(self, request, slug, pk):
+        quick_link = WorkspaceUserLink.objects.filter(pk=pk, workspace__slug=slug, owner=request.user).first()
+
+        if quick_link:
+            serializer = WorkspaceUserLinkSerializer(quick_link, 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)
+        return Response({"detail": "Quick link not found."}, status=status.HTTP_404_NOT_FOUND)
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], level="WORKSPACE")
+    def retrieve(self, request, slug, pk):
+        try:
+            quick_link = WorkspaceUserLink.objects.get(pk=pk, workspace__slug=slug, owner=request.user)
+            serializer = WorkspaceUserLinkSerializer(quick_link)
+            return Response(serializer.data, status=status.HTTP_200_OK)
+        except WorkspaceUserLink.DoesNotExist:
+            return Response({"error": "Quick link not found."}, status=status.HTTP_404_NOT_FOUND)
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], level="WORKSPACE")
+    def destroy(self, request, slug, pk):
+        quick_link = WorkspaceUserLink.objects.get(pk=pk, workspace__slug=slug, owner=request.user)
+        quick_link.delete()
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], level="WORKSPACE")
+    def list(self, request, slug):
+        quick_links = WorkspaceUserLink.objects.filter(workspace__slug=slug, owner=request.user)
+
+        serializer = WorkspaceUserLinkSerializer(quick_links, many=True)
+        return Response(serializer.data, status=status.HTTP_200_OK)

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

@@ -0,0 +1,36 @@
+# 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.db.models import UserRecentVisit
+from plane.app.serializers import WorkspaceRecentVisitSerializer
+
+# Modules imports
+from ..base import BaseViewSet
+from plane.app.permissions import allow_permission, ROLE
+
+
+class UserRecentVisitViewSet(BaseViewSet):
+    model = UserRecentVisit
+    use_read_replica = True
+
+    def get_serializer_class(self):
+        return WorkspaceRecentVisitSerializer
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], level="WORKSPACE")
+    def list(self, request, slug):
+        user_recent_visits = UserRecentVisit.objects.filter(workspace__slug=slug, user=request.user)
+
+        entity_name = request.query_params.get("entity_name")
+
+        if entity_name:
+            user_recent_visits = user_recent_visits.filter(entity_name=entity_name)
+
+        user_recent_visits = user_recent_visits.filter(entity_name__in=["issue", "page", "project"])
+
+        serializer = WorkspaceRecentVisitSerializer(user_recent_visits[:20], many=True)
+        return Response(serializer.data, status=status.HTTP_200_OK)

plane-src/apps/api/plane/app/views/workspace/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.
+
+# Third party modules
+from rest_framework import status
+from rest_framework.response import Response
+
+# Module imports
+from plane.app.serializers import StateSerializer
+from plane.app.views.base import BaseAPIView
+from plane.db.models import State
+from plane.app.permissions import WorkspaceEntityPermission
+from collections import defaultdict
+
+
+class WorkspaceStatesEndpoint(BaseAPIView):
+    permission_classes = [WorkspaceEntityPermission]
+    use_read_replica = True
+
+    def get(self, request, slug):
+        states = State.objects.filter(
+            workspace__slug=slug,
+            project__project_projectmember__member=request.user,
+            project__project_projectmember__is_active=True,
+            project__archived_at__isnull=True,
+            is_triage=False,
+        )
+
+        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
+
+        serializer = StateSerializer(states, many=True).data
+        return Response(serializer, status=status.HTTP_200_OK)

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

@@ -0,0 +1,60 @@
+# 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 plane.app.views.base import BaseViewSet
+from plane.app.permissions import ROLE, allow_permission
+from plane.db.models import Sticky, Workspace
+from plane.app.serializers import StickySerializer
+
+
+class WorkspaceStickyViewSet(BaseViewSet):
+    serializer_class = StickySerializer
+    model = Sticky
+    use_read_replica = True
+
+    def get_queryset(self):
+        return self.filter_queryset(
+            super()
+            .get_queryset()
+            .filter(workspace__slug=self.kwargs.get("slug"))
+            .filter(owner_id=self.request.user.id)
+            .select_related("workspace", "owner")
+            .distinct()
+        )
+
+    @allow_permission(allowed_roles=[ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], level="WORKSPACE")
+    def create(self, request, slug):
+        workspace = Workspace.objects.get(slug=slug)
+        serializer = StickySerializer(data=request.data)
+        if serializer.is_valid():
+            serializer.save(workspace_id=workspace.id, owner_id=request.user.id)
+            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, ROLE.MEMBER, ROLE.GUEST], level="WORKSPACE")
+    def list(self, request, slug):
+        query = request.query_params.get("query", False)
+        stickies = self.get_queryset().order_by("-sort_order")
+        if query:
+            stickies = stickies.filter(description_stripped__icontains=query)
+
+        return self.paginate(
+            request=request,
+            queryset=(stickies),
+            on_results=lambda stickies: StickySerializer(stickies, many=True).data,
+            default_per_page=20,
+        )
+
+    @allow_permission(allowed_roles=[], creator=True, model=Sticky, level="WORKSPACE")
+    def partial_update(self, request, *args, **kwargs):
+        return super().partial_update(request, *args, **kwargs)
+
+    @allow_permission(allowed_roles=[], creator=True, model=Sticky, level="WORKSPACE")
+    def destroy(self, request, *args, **kwargs):
+        return super().destroy(request, *args, **kwargs)

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

@@ -0,0 +1,558 @@
+# 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
+from datetime import date
+
+from dateutil.relativedelta import relativedelta
+
+# Django imports
+from django.db.models import (
+    Case,
+    Count,
+    F,
+    Func,
+    IntegerField,
+    OuterRef,
+    Q,
+    Value,
+    When,
+    Subquery,
+)
+from django.db.models.fields import DateField
+from django.db.models.functions import Cast, ExtractWeek
+from django.utils import timezone
+
+# Third party modules
+from rest_framework import status
+from rest_framework.response import Response
+
+from plane.app.permissions import WorkspaceEntityPermission, WorkspaceViewerPermission
+
+# Module imports
+from plane.app.serializers import (
+    IssueActivitySerializer,
+    ProjectMemberSerializer,
+    WorkSpaceSerializer,
+    WorkspaceUserPropertiesSerializer,
+)
+from plane.app.views.base import BaseAPIView
+from plane.db.models import (
+    CycleIssue,
+    Issue,
+    IssueActivity,
+    FileAsset,
+    IssueLink,
+    IssueSubscriber,
+    Project,
+    ProjectMember,
+    User,
+    Workspace,
+    WorkspaceMember,
+    WorkspaceUserProperties,
+)
+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
+
+
+class UserLastProjectWithWorkspaceEndpoint(BaseAPIView):
+    def get(self, request):
+        user = User.objects.get(pk=request.user.id)
+
+        last_workspace_id = user.last_workspace_id
+
+        if last_workspace_id is None:
+            return Response(
+                {"project_details": [], "workspace_details": {}},
+                status=status.HTTP_200_OK,
+            )
+
+        workspace = Workspace.objects.get(pk=last_workspace_id)
+        workspace_serializer = WorkSpaceSerializer(workspace)
+
+        project_member = ProjectMember.objects.filter(
+            workspace_id=last_workspace_id, member=request.user
+        ).select_related("workspace", "project", "member", "workspace__owner")
+
+        project_member_serializer = ProjectMemberSerializer(project_member, many=True)
+
+        return Response(
+            {
+                "workspace_details": workspace_serializer.data,
+                "project_details": project_member_serializer.data,
+            },
+            status=status.HTTP_200_OK,
+        )
+
+
+class WorkspaceUserProfileIssuesEndpoint(BaseAPIView):
+    permission_classes = [WorkspaceViewerPermission]
+
+    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(self, request, slug, user_id):
+        filters = issue_filters(request.query_params, "GET")
+
+        order_by_param = request.GET.get("order_by", "-created_at")
+        issue_queryset = Issue.issue_objects.filter(
+            id__in=Issue.issue_objects.filter(
+                Q(assignees__in=[user_id]) | Q(created_by_id=user_id) | Q(issue_subscribers__subscriber_id=user_id),
+                workspace__slug=slug,
+            ).values_list("id", flat=True),
+            workspace__slug=slug,
+            project__project_projectmember__member=request.user,
+            project__project_projectmember__is_active=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)
+
+        # 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
+        )
+
+        # 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:
+            if sub_group_by:
+                if group_by == sub_group_by:
+                    return Response(
+                        {
+                            "error": "Group by and sub group by cannot have same parameters"  # noqa: E501
+                        },
+                        status=status.HTTP_400_BAD_REQUEST,
+                    )
+                else:
+                    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,
+                            filters=filters,
+                            queryset=total_issue_queryset,
+                        ),
+                        sub_group_by_fields=issue_group_values(
+                            field=sub_group_by,
+                            slug=slug,
+                            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,
+                        ),
+                    )
+            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,
+                        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:
+            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),
+            )
+
+
+class WorkspaceUserPropertiesEndpoint(BaseAPIView):
+    permission_classes = [WorkspaceViewerPermission]
+
+    def patch(self, request, slug):
+        workspace = Workspace.objects.get(slug=slug)
+
+        (workspace_properties, _) = WorkspaceUserProperties.objects.get_or_create(
+            user=request.user, workspace_id=workspace.id
+        )
+
+        serializer = WorkspaceUserPropertiesSerializer(workspace_properties, 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 get(self, request, slug):
+        workspace = Workspace.objects.get(slug=slug)
+
+        (workspace_properties, _) = WorkspaceUserProperties.objects.get_or_create(
+            user=request.user, workspace=workspace
+        )
+
+        serializer = WorkspaceUserPropertiesSerializer(workspace_properties)
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+
+class WorkspaceUserProfileEndpoint(BaseAPIView):
+    def get(self, request, slug, user_id):
+        user_data = User.objects.get(pk=user_id)
+
+        requesting_workspace_member = WorkspaceMember.objects.get(
+            workspace__slug=slug, member=request.user, is_active=True
+        )
+        projects = []
+        if requesting_workspace_member.role >= 15:
+            projects = (
+                Project.objects.filter(
+                    workspace__slug=slug,
+                    project_projectmember__member=request.user,
+                    project_projectmember__is_active=True,
+                    archived_at__isnull=True,
+                )
+                .annotate(
+                    created_issues=Count(
+                        "project_issue",
+                        filter=Q(
+                            project_issue__created_by_id=user_id,
+                            project_issue__archived_at__isnull=True,
+                            project_issue__is_draft=False,
+                        ),
+                    )
+                )
+                .annotate(
+                    assigned_issues=Count(
+                        "project_issue",
+                        filter=Q(
+                            project_issue__assignees__in=[user_id],
+                            project_issue__archived_at__isnull=True,
+                            project_issue__is_draft=False,
+                        ),
+                    )
+                )
+                .annotate(
+                    completed_issues=Count(
+                        "project_issue",
+                        filter=Q(
+                            project_issue__completed_at__isnull=False,
+                            project_issue__assignees__in=[user_id],
+                            project_issue__archived_at__isnull=True,
+                            project_issue__is_draft=False,
+                        ),
+                    )
+                )
+                .annotate(
+                    pending_issues=Count(
+                        "project_issue",
+                        filter=Q(
+                            project_issue__state__group__in=[
+                                "backlog",
+                                "unstarted",
+                                "started",
+                            ],
+                            project_issue__assignees__in=[user_id],
+                            project_issue__archived_at__isnull=True,
+                            project_issue__is_draft=False,
+                        ),
+                    )
+                )
+                .values(
+                    "id",
+                    "logo_props",
+                    "created_issues",
+                    "assigned_issues",
+                    "completed_issues",
+                    "pending_issues",
+                )
+            )
+
+        return Response(
+            {
+                "project_data": projects,
+                "user_data": {
+                    "email": user_data.email,
+                    "first_name": user_data.first_name,
+                    "last_name": user_data.last_name,
+                    "avatar_url": user_data.avatar_url,
+                    "cover_image_url": user_data.cover_image_url,
+                    "date_joined": user_data.date_joined,
+                    "user_timezone": user_data.user_timezone,
+                    "display_name": user_data.display_name,
+                },
+            },
+            status=status.HTTP_200_OK,
+        )
+
+
+class WorkspaceUserActivityEndpoint(BaseAPIView):
+    permission_classes = [WorkspaceEntityPermission]
+
+    def get(self, request, slug, user_id):
+        projects = request.query_params.getlist("project", [])
+
+        queryset = IssueActivity.objects.filter(
+            ~Q(field__in=["comment", "vote", "reaction", "draft"]),
+            workspace__slug=slug,
+            project__project_projectmember__member=request.user,
+            project__project_projectmember__is_active=True,
+            project__archived_at__isnull=True,
+            actor=user_id,
+        ).select_related("actor", "workspace", "issue", "project")
+
+        if projects:
+            queryset = queryset.filter(project__in=projects)
+
+        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 WorkspaceUserProfileStatsEndpoint(BaseAPIView):
+    def get(self, request, slug, user_id):
+        filters = issue_filters(request.query_params, "GET")
+
+        state_distribution = (
+            Issue.issue_objects.filter(
+                (Q(assignees__in=[user_id]) & Q(issue_assignee__deleted_at__isnull=True)),
+                workspace__slug=slug,
+                project__project_projectmember__member=request.user,
+                project__project_projectmember__is_active=True,
+            )
+            .filter(**filters)
+            .annotate(state_group=F("state__group"))
+            .values("state_group")
+            .annotate(state_count=Count("state_group"))
+            .order_by("state_group")
+        )
+
+        priority_order = ["urgent", "high", "medium", "low", "none"]
+
+        priority_distribution = (
+            Issue.issue_objects.filter(
+                (Q(assignees__in=[user_id]) & Q(issue_assignee__deleted_at__isnull=True)),
+                workspace__slug=slug,
+                project__project_projectmember__member=request.user,
+                project__project_projectmember__is_active=True,
+            )
+            .filter(**filters)
+            .values("priority")
+            .annotate(priority_count=Count("priority"))
+            .filter(priority_count__gte=1)
+            .annotate(
+                priority_order=Case(
+                    *[When(priority=p, then=Value(i)) for i, p in enumerate(priority_order)],
+                    default=Value(len(priority_order)),
+                    output_field=IntegerField(),
+                )
+            )
+            .order_by("priority_order")
+        )
+
+        created_issues = (
+            Issue.issue_objects.filter(
+                workspace__slug=slug,
+                project__project_projectmember__member=request.user,
+                project__project_projectmember__is_active=True,
+                created_by_id=user_id,
+            )
+            .filter(**filters)
+            .count()
+        )
+
+        assigned_issues_count = (
+            Issue.issue_objects.filter(
+                (Q(assignees__in=[user_id]) & Q(issue_assignee__deleted_at__isnull=True)),
+                workspace__slug=slug,
+                project__project_projectmember__member=request.user,
+                project__project_projectmember__is_active=True,
+            )
+            .filter(**filters)
+            .count()
+        )
+
+        pending_issues_count = (
+            Issue.issue_objects.filter(
+                ~Q(state__group__in=["completed", "cancelled"]),
+                (Q(assignees__in=[user_id]) & Q(issue_assignee__deleted_at__isnull=True)),
+                workspace__slug=slug,
+                project__project_projectmember__member=request.user,
+                project__project_projectmember__is_active=True,
+            )
+            .filter(**filters)
+            .count()
+        )
+
+        completed_issues_count = (
+            Issue.issue_objects.filter(
+                (Q(assignees__in=[user_id]) & Q(issue_assignee__deleted_at__isnull=True)),
+                workspace__slug=slug,
+                state__group="completed",
+                project__project_projectmember__member=request.user,
+                project__project_projectmember__is_active=True,
+            )
+            .filter(**filters)
+            .count()
+        )
+
+        subscribed_issues_count = (
+            IssueSubscriber.objects.filter(
+                workspace__slug=slug,
+                subscriber_id=user_id,
+                project__project_projectmember__member=request.user,
+                project__project_projectmember__is_active=True,
+                project__archived_at__isnull=True,
+            )
+            .filter(**filters)
+            .count()
+        )
+
+        upcoming_cycles = CycleIssue.objects.filter(
+            workspace__slug=slug,
+            cycle__start_date__gt=timezone.now(),
+            issue__assignees__in=[user_id],
+        ).values("cycle__name", "cycle__id", "cycle__project_id")
+
+        present_cycle = CycleIssue.objects.filter(
+            workspace__slug=slug,
+            cycle__start_date__lt=timezone.now(),
+            cycle__end_date__gt=timezone.now(),
+            issue__assignees__in=[user_id],
+        ).values("cycle__name", "cycle__id", "cycle__project_id")
+
+        return Response(
+            {
+                "state_distribution": state_distribution,
+                "priority_distribution": priority_distribution,
+                "created_issues": created_issues,
+                "assigned_issues": assigned_issues_count,
+                "completed_issues": completed_issues_count,
+                "pending_issues": pending_issues_count,
+                "subscribed_issues": subscribed_issues_count,
+                "present_cycles": present_cycle,
+                "upcoming_cycles": upcoming_cycles,
+            }
+        )
+
+
+class UserActivityGraphEndpoint(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=-6),
+            )
+            .annotate(created_date=Cast("created_at", DateField()))
+            .values("created_date")
+            .annotate(activity_count=Count("created_date"))
+            .order_by("created_date")
+        )
+
+        return Response(issue_activities, status=status.HTTP_200_OK)
+
+
+class UserIssueCompletedGraphEndpoint(BaseAPIView):
+    def get(self, request, slug):
+        month = request.GET.get("month", 1)
+
+        issues = (
+            Issue.issue_objects.filter(
+                assignees__in=[request.user],
+                workspace__slug=slug,
+                completed_at__month=month,
+                completed_at__isnull=False,
+            )
+            .annotate(completed_week=ExtractWeek("completed_at"))
+            .annotate(week=F("completed_week") % 4)
+            .values("week")
+            .annotate(completed_count=Count("completed_week"))
+            .order_by("week")
+        )
+
+        return Response(issues, status=status.HTTP_200_OK)

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

@@ -0,0 +1,101 @@
+# 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 BaseAPIView
+from plane.db.models.workspace import WorkspaceUserPreference
+from plane.app.serializers.workspace import WorkspaceUserPreferenceSerializer
+from plane.app.permissions import allow_permission, ROLE
+from plane.db.models import Workspace
+
+
+# Third party imports
+from rest_framework.response import Response
+from rest_framework import status
+
+
+class WorkspaceUserPreferenceViewSet(BaseAPIView):
+    model = WorkspaceUserPreference
+    use_read_replica = True
+
+    def get_serializer_class(self):
+        return WorkspaceUserPreferenceSerializer
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], level="WORKSPACE")
+    def get(self, request, slug):
+        workspace = Workspace.objects.get(slug=slug)
+
+        get_preference = WorkspaceUserPreference.objects.filter(user=request.user, workspace_id=workspace.id)
+
+        create_preference_keys = []
+
+        keys = [key for key, _ in WorkspaceUserPreference.UserPreferenceKeys.choices]
+
+        for preference in keys:
+            if preference not in get_preference.values_list("key", flat=True):
+                create_preference_keys.append(preference)
+
+                preference = WorkspaceUserPreference.objects.bulk_create(
+                    [
+                        WorkspaceUserPreference(
+                            key=key,
+                            user=request.user,
+                            workspace=workspace,
+                            sort_order=(65535 + (i * 10000)),
+                            is_pinned=(
+                                True
+                                if key
+                                in [
+                                    WorkspaceUserPreference.UserPreferenceKeys.DRAFTS,
+                                    WorkspaceUserPreference.UserPreferenceKeys.YOUR_WORK,
+                                    WorkspaceUserPreference.UserPreferenceKeys.STICKIES,
+                                ]
+                                else False
+                            ),
+                        )
+                        for i, key in enumerate(create_preference_keys)
+                    ],
+                    batch_size=10,
+                    ignore_conflicts=True,
+                )
+
+        preferences = (
+            WorkspaceUserPreference.objects.filter(user=request.user, workspace_id=workspace.id)
+            .order_by("sort_order")
+            .values("key", "is_pinned", "sort_order")
+        )
+
+        user_preferences = {}
+
+        for preference in preferences:
+            user_preferences[(str(preference["key"]))] = {
+                "is_pinned": preference["is_pinned"],
+                "sort_order": preference["sort_order"],
+            }
+        return Response(
+            user_preferences,
+            status=status.HTTP_200_OK,
+        )
+
+    @allow_permission([ROLE.ADMIN, ROLE.MEMBER, ROLE.GUEST], level="WORKSPACE")
+    def patch(self, request, slug):
+        for data in request.data:
+            key = data.pop("key", None)
+            if not key:
+                continue
+
+            preference = WorkspaceUserPreference.objects.filter(key=key, workspace__slug=slug).first()
+
+            if not preference:
+                continue
+
+            if "is_pinned" in data:
+                preference.is_pinned = data["is_pinned"]
+
+            if "sort_order" in data:
+                preference.sort_order = data["sort_order"]
+
+            preference.save(update_fields=["is_pinned", "sort_order"])
+
+        return Response({"message": "Successfully updated"}, status=status.HTTP_200_OK)