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