967 lines
38 KiB
Python
967 lines
38 KiB
Python
# Copyright (c) 2023-present Plane Software, Inc. and contributors
|
|
# SPDX-License-Identifier: AGPL-3.0-only
|
|
# See the LICENSE file for details.
|
|
|
|
from django.http import HttpResponseRedirect
|
|
from django.db.models import Q
|
|
from django.shortcuts import get_object_or_404
|
|
from django.utils import timezone
|
|
from rest_framework.exceptions import ValidationError
|
|
from rest_framework import status
|
|
from rest_framework.response import Response
|
|
from plane.utils.host import base_host
|
|
|
|
from plane.api.serializers import (
|
|
ExternalContourBoardItemSerializer,
|
|
ExternalContourRequestCreateSerializer,
|
|
ExternalContourRequestDecisionSerializer,
|
|
ExternalContourRequestReplySerializer,
|
|
ExternalContourRequestUpdateSerializer,
|
|
ExternalContourRequestSerializer,
|
|
ExternalContourTargetOptionsSerializer,
|
|
ExternalContourTargetProjectSerializer,
|
|
)
|
|
from plane.api.serializers.issue import IssueSerializer as IssueCreateSerializer
|
|
from plane.app.permissions import ProjectLitePermission
|
|
from plane.app.realtime.issue_events import publish_external_contour_event_on_commit, publish_issue_event_on_commit
|
|
from plane.app.views.base import BaseAPIView
|
|
from plane.db.models import FileAsset, Intake, IntakeIssue, Label, Notification, Project, ProjectMember, State, StateGroup
|
|
from plane.db.models.intake import IntakeIssueStatus, SourceType
|
|
from plane.settings.storage import S3Storage
|
|
from plane.utils.external_contours import create_external_contour_issue_comment
|
|
|
|
|
|
class ExternalContourListCreateEndpoint(BaseAPIView):
|
|
permission_classes = [ProjectLitePermission]
|
|
serializer_class = ExternalContourRequestSerializer
|
|
|
|
def get_source_project(self, slug, project_id):
|
|
return get_object_or_404(Project, workspace__slug=slug, pk=project_id)
|
|
|
|
def get_default_target_state(self, target_project):
|
|
return (
|
|
State.objects.filter(project=target_project, default=True)
|
|
.exclude(group=StateGroup.TRIAGE.value)
|
|
.first()
|
|
) or State.objects.filter(project=target_project).exclude(group=StateGroup.TRIAGE.value).order_by(
|
|
"sequence", "created_at"
|
|
).first()
|
|
|
|
def get_queryset(self):
|
|
return (
|
|
IntakeIssue.objects.filter(
|
|
workspace__slug=self.kwargs.get("slug"),
|
|
extra__bridge="external-contours",
|
|
extra__source_project_id=str(self.kwargs.get("project_id")),
|
|
)
|
|
.select_related(
|
|
"issue",
|
|
"issue__state",
|
|
"issue__project",
|
|
"issue__created_by",
|
|
)
|
|
.prefetch_related("issue__issue_assignee__assignee", "issue__label_issue__label")
|
|
.order_by("-updated_at")
|
|
)
|
|
|
|
def get(self, request, slug, project_id):
|
|
serializer = ExternalContourRequestSerializer(
|
|
self.get_queryset(),
|
|
many=True,
|
|
context={"request": request},
|
|
)
|
|
return Response(
|
|
{
|
|
"results": serializer.data,
|
|
"next_cursor": "",
|
|
"prev_cursor": "",
|
|
"next_page_results": False,
|
|
"prev_page_results": False,
|
|
"total_count": len(serializer.data),
|
|
"count": len(serializer.data),
|
|
"total_pages": 1,
|
|
"extra_stats": None,
|
|
"total_results": len(serializer.data),
|
|
},
|
|
status=status.HTTP_200_OK,
|
|
)
|
|
|
|
def post(self, request, slug, project_id):
|
|
source_project = self.get_source_project(slug, project_id)
|
|
serializer = ExternalContourRequestCreateSerializer(data=request.data)
|
|
serializer.is_valid(raise_exception=True)
|
|
|
|
target_project = get_object_or_404(
|
|
Project,
|
|
workspace_id=source_project.workspace_id,
|
|
pk=serializer.validated_data["target_project_id"],
|
|
archived_at__isnull=True,
|
|
)
|
|
|
|
if str(target_project.id) == str(source_project.id):
|
|
return Response({"error": "Target project must differ from source project"}, status=status.HTTP_400_BAD_REQUEST)
|
|
|
|
if not target_project.intake_view:
|
|
return Response(
|
|
{"error": "Target project is not enabled for external contour routing"},
|
|
status=status.HTTP_400_BAD_REQUEST,
|
|
)
|
|
|
|
triage_state = State.triage_objects.filter(project=target_project).first()
|
|
if not triage_state:
|
|
triage_state = State.objects.create(
|
|
name="Triage",
|
|
group=StateGroup.TRIAGE.value,
|
|
project=target_project,
|
|
color="#4E5355",
|
|
sequence=65000,
|
|
default=False,
|
|
)
|
|
|
|
target_default_state = self.get_default_target_state(target_project)
|
|
|
|
if not target_default_state:
|
|
return Response({"error": "Target project has no available workflow state"}, status=status.HTTP_400_BAD_REQUEST)
|
|
|
|
intake = Intake.objects.filter(project=target_project, name="External Contours Bridge").first()
|
|
if not intake:
|
|
intake = Intake.objects.create(
|
|
name="External Contours Bridge",
|
|
description="System bridge intake used for cross-project routing.",
|
|
is_default=False,
|
|
project=target_project,
|
|
)
|
|
|
|
issue_payload = serializer.validated_data["issue"]
|
|
issue_serializer = IssueCreateSerializer(
|
|
data={
|
|
"name": issue_payload["name"],
|
|
"description_html": issue_payload.get("description_html") or "<p></p>",
|
|
"priority": issue_payload.get("priority", "none"),
|
|
"assignees": issue_payload.get("assignee_ids", []),
|
|
"labels": issue_payload.get("label_ids", []),
|
|
"target_date": issue_payload.get("target_date"),
|
|
"state_id": str(triage_state.id),
|
|
},
|
|
context={
|
|
"project_id": str(target_project.id),
|
|
"workspace_id": str(target_project.workspace_id),
|
|
"default_assignee_id": target_project.default_assignee_id,
|
|
},
|
|
)
|
|
issue_serializer.is_valid(raise_exception=True)
|
|
issue = issue_serializer.save(state=triage_state)
|
|
|
|
intake_issue = IntakeIssue.objects.create(
|
|
intake=intake,
|
|
project=target_project,
|
|
issue=issue,
|
|
source=SourceType.IN_APP,
|
|
status=IntakeIssueStatus.ACCEPTED.value,
|
|
extra={
|
|
"bridge": "external-contours",
|
|
"source_project_id": str(source_project.id),
|
|
"source_project_name": source_project.name,
|
|
"target_project_id": str(target_project.id),
|
|
"target_project_name": target_project.name,
|
|
"requested_by_id": str(request.user.id),
|
|
"requested_by_name": request.user.display_name,
|
|
"requested_at": issue.created_at.isoformat() if issue.created_at else None,
|
|
},
|
|
)
|
|
|
|
if issue.state_id != target_default_state.id:
|
|
issue.state = target_default_state
|
|
issue.save()
|
|
|
|
publish_issue_event_on_commit(
|
|
"issue.created",
|
|
issue,
|
|
actor_id=request.user.id,
|
|
changed_fields=[
|
|
"name",
|
|
"description_html",
|
|
"priority",
|
|
"assignees",
|
|
"labels",
|
|
"target_date",
|
|
"state",
|
|
"external_contour",
|
|
],
|
|
publish_external_bridge=False,
|
|
)
|
|
publish_external_contour_event_on_commit(
|
|
"external_contour.created",
|
|
intake_issue,
|
|
actor_id=request.user.id,
|
|
changed_fields=["issue", "state", "external_contour"],
|
|
)
|
|
|
|
response_serializer = ExternalContourRequestSerializer(
|
|
IntakeIssue.objects.select_related(
|
|
"issue",
|
|
"issue__state",
|
|
"issue__project",
|
|
"issue__created_by",
|
|
)
|
|
.prefetch_related("issue__issue_assignee__assignee", "issue__label_issue__label")
|
|
.get(pk=intake_issue.id),
|
|
context={"request": request},
|
|
)
|
|
return Response(response_serializer.data, status=status.HTTP_201_CREATED)
|
|
|
|
|
|
class ExternalContourTargetProjectListEndpoint(BaseAPIView):
|
|
permission_classes = [ProjectLitePermission]
|
|
serializer_class = ExternalContourTargetProjectSerializer
|
|
|
|
def get_source_project(self, slug, project_id):
|
|
return get_object_or_404(Project, workspace__slug=slug, pk=project_id)
|
|
|
|
def get_queryset(self):
|
|
source_project = self.get_source_project(self.kwargs.get("slug"), self.kwargs.get("project_id"))
|
|
return (
|
|
Project.objects.filter(
|
|
workspace_id=source_project.workspace_id,
|
|
archived_at__isnull=True,
|
|
intake_view=True,
|
|
)
|
|
.exclude(pk=source_project.id)
|
|
.order_by("name")
|
|
)
|
|
|
|
def get(self, request, slug, project_id):
|
|
serializer = ExternalContourTargetProjectSerializer(self.get_queryset(), many=True)
|
|
return Response(serializer.data, status=status.HTTP_200_OK)
|
|
|
|
|
|
class ExternalContourTargetOptionsEndpoint(BaseAPIView):
|
|
permission_classes = [ProjectLitePermission]
|
|
serializer_class = ExternalContourTargetOptionsSerializer
|
|
|
|
def get_source_project(self, slug, project_id):
|
|
return get_object_or_404(Project, workspace__slug=slug, pk=project_id)
|
|
|
|
def get_target_project(self, source_project, target_project_id):
|
|
return get_object_or_404(
|
|
Project,
|
|
workspace_id=source_project.workspace_id,
|
|
pk=target_project_id,
|
|
archived_at__isnull=True,
|
|
intake_view=True,
|
|
)
|
|
|
|
def get(self, request, slug, project_id, target_project_id):
|
|
source_project = self.get_source_project(slug, project_id)
|
|
target_project = self.get_target_project(source_project, target_project_id)
|
|
|
|
if str(target_project.id) == str(source_project.id):
|
|
return Response({"error": "Target project must differ from source project"}, status=status.HTTP_400_BAD_REQUEST)
|
|
|
|
member_ids = list(
|
|
ProjectMember.objects.filter(
|
|
project=target_project,
|
|
workspace_id=target_project.workspace_id,
|
|
is_active=True,
|
|
member__is_bot=False,
|
|
member__member_workspace__workspace_id=target_project.workspace_id,
|
|
member__member_workspace__is_active=True,
|
|
)
|
|
.order_by("member__display_name", "member__email")
|
|
.values_list("member_id", flat=True)
|
|
.distinct()
|
|
)
|
|
|
|
labels = Label.objects.filter(project=target_project).order_by("sort_order", "name")
|
|
states = State.objects.filter(project=target_project).exclude(group=StateGroup.TRIAGE.value).order_by(
|
|
"sequence", "created_at"
|
|
)
|
|
|
|
serializer = ExternalContourTargetOptionsSerializer(
|
|
{
|
|
"project": target_project,
|
|
"member_ids": member_ids,
|
|
"states": states,
|
|
"labels": labels,
|
|
}
|
|
)
|
|
return Response(serializer.data, status=status.HTTP_200_OK)
|
|
|
|
|
|
class ExternalContourReadMixin:
|
|
CLOSED_STATE_GROUPS = (StateGroup.COMPLETED.value, StateGroup.CANCELLED.value)
|
|
BOARD_ORDERING_MAP = {
|
|
"requested_at": "created_at",
|
|
"updated_at": "updated_at",
|
|
"issue__sequence_id": "issue__sequence_id",
|
|
"target_date": "issue__target_date",
|
|
}
|
|
|
|
def get_base_queryset(self):
|
|
return (
|
|
IntakeIssue.objects.filter(
|
|
workspace__slug=self.kwargs.get("slug"),
|
|
extra__bridge="external-contours",
|
|
)
|
|
.select_related(
|
|
"issue",
|
|
"issue__state",
|
|
"issue__project",
|
|
"issue__created_by",
|
|
)
|
|
.prefetch_related("issue__issue_assignee__assignee", "issue__label_issue__label")
|
|
)
|
|
|
|
def get_outgoing_queryset(self):
|
|
return self.get_base_queryset().filter(extra__source_project_id=str(self.kwargs.get("project_id")))
|
|
|
|
def get_incoming_queryset(self):
|
|
return self.get_base_queryset().filter(project_id=self.kwargs.get("project_id"))
|
|
|
|
def get_board_item_queryset(self):
|
|
return self.get_base_queryset().filter(
|
|
Q(extra__source_project_id=str(self.kwargs.get("project_id"))) | Q(project_id=self.kwargs.get("project_id"))
|
|
)
|
|
|
|
def parse_csv_param(self, request, key):
|
|
value = (request.query_params.get(key) or "").strip()
|
|
if not value:
|
|
return []
|
|
return [item.strip() for item in value.split(",") if item.strip()]
|
|
|
|
def parse_bool_param(self, request, key):
|
|
value = (request.query_params.get(key) or "").strip().lower()
|
|
if value in ["true", "1", "yes"]:
|
|
return True
|
|
if value in ["false", "0", "no"]:
|
|
return False
|
|
return None
|
|
|
|
def get_requested_directions(self, request):
|
|
directions = set(self.parse_csv_param(request, "direction"))
|
|
valid_directions = {"outgoing", "incoming"}
|
|
return directions.intersection(valid_directions) or valid_directions
|
|
|
|
def get_applied_filters(self, request):
|
|
filters = {}
|
|
for key in [
|
|
"direction",
|
|
"status",
|
|
"state_groups",
|
|
"state_ids",
|
|
"priority",
|
|
"assignee_ids",
|
|
"created_by_ids",
|
|
"requested_by_ids",
|
|
"counterparty_project_ids",
|
|
"source_project_ids",
|
|
"target_project_ids",
|
|
"label_ids",
|
|
]:
|
|
filters[key] = self.parse_csv_param(request, key)
|
|
|
|
filters["has_unread_updates"] = self.parse_bool_param(request, "has_unread_updates")
|
|
filters["search"] = (request.query_params.get("search") or "").strip()
|
|
filters["target_date_exact"] = (request.query_params.get("target_date_exact") or "").strip()
|
|
filters["target_date_from"] = (request.query_params.get("target_date_from") or "").strip()
|
|
filters["target_date_to"] = (request.query_params.get("target_date_to") or "").strip()
|
|
return filters
|
|
|
|
def get_sorting(self, request):
|
|
order_by = (request.query_params.get("order_by") or "updated_at").strip()
|
|
sort_by = (request.query_params.get("sort_by") or "desc").strip().lower()
|
|
|
|
if order_by not in self.BOARD_ORDERING_MAP:
|
|
order_by = "updated_at"
|
|
if sort_by not in ["asc", "desc"]:
|
|
sort_by = "desc"
|
|
|
|
return {
|
|
"order_by": order_by,
|
|
"sort_by": sort_by,
|
|
}
|
|
|
|
def get_unread_request_ids(self, user, request_ids=None):
|
|
user_id = getattr(user, "id", None)
|
|
if not user_id:
|
|
return set()
|
|
|
|
queryset = Notification.objects.filter(
|
|
receiver_id=user_id,
|
|
sender__startswith="in_app:external_contours:",
|
|
read_at__isnull=True,
|
|
)
|
|
if request_ids:
|
|
queryset = queryset.filter(data__issue__id__in=[str(request_id) for request_id in request_ids])
|
|
|
|
return {
|
|
str(request_id)
|
|
for request_id in queryset.values_list("data__issue__id", flat=True)
|
|
if request_id
|
|
}
|
|
|
|
def apply_status_filter(self, queryset, statuses):
|
|
normalized_statuses = {status_value for status_value in statuses if status_value in ["open", "closed"]}
|
|
if not normalized_statuses or normalized_statuses == {"open", "closed"}:
|
|
return queryset
|
|
if normalized_statuses == {"open"}:
|
|
return queryset.exclude(issue__state__group__in=self.CLOSED_STATE_GROUPS)
|
|
if normalized_statuses == {"closed"}:
|
|
return queryset.filter(issue__state__group__in=self.CLOSED_STATE_GROUPS)
|
|
return queryset
|
|
|
|
def apply_board_filters(self, queryset, request, direction=None):
|
|
filters = self.get_applied_filters(request)
|
|
|
|
if filters["search"]:
|
|
queryset = queryset.filter(
|
|
Q(issue__name__icontains=filters["search"]) | Q(issue__description_html__icontains=filters["search"])
|
|
)
|
|
|
|
queryset = self.apply_status_filter(queryset, filters["status"])
|
|
|
|
if filters["state_groups"]:
|
|
queryset = queryset.filter(issue__state__group__in=filters["state_groups"])
|
|
if filters["state_ids"]:
|
|
queryset = queryset.filter(issue__state_id__in=filters["state_ids"])
|
|
if filters["priority"]:
|
|
queryset = queryset.filter(issue__priority__in=filters["priority"])
|
|
if filters["assignee_ids"]:
|
|
queryset = queryset.filter(issue__issue_assignee__assignee_id__in=filters["assignee_ids"])
|
|
if filters["created_by_ids"]:
|
|
queryset = queryset.filter(issue__created_by_id__in=filters["created_by_ids"])
|
|
if filters["requested_by_ids"]:
|
|
queryset = queryset.filter(extra__requested_by_id__in=filters["requested_by_ids"])
|
|
if filters["counterparty_project_ids"]:
|
|
if direction == "outgoing":
|
|
queryset = queryset.filter(
|
|
Q(extra__target_project_id__in=filters["counterparty_project_ids"])
|
|
| Q(issue__project_id__in=filters["counterparty_project_ids"])
|
|
)
|
|
elif direction == "incoming":
|
|
queryset = queryset.filter(extra__source_project_id__in=filters["counterparty_project_ids"])
|
|
if filters["source_project_ids"]:
|
|
queryset = queryset.filter(extra__source_project_id__in=filters["source_project_ids"])
|
|
if filters["target_project_ids"]:
|
|
queryset = queryset.filter(
|
|
Q(extra__target_project_id__in=filters["target_project_ids"])
|
|
| Q(issue__project_id__in=filters["target_project_ids"])
|
|
)
|
|
if filters["label_ids"]:
|
|
queryset = queryset.filter(issue__label_issue__label_id__in=filters["label_ids"])
|
|
if filters["target_date_exact"]:
|
|
queryset = queryset.filter(issue__target_date=filters["target_date_exact"])
|
|
if filters["target_date_from"]:
|
|
queryset = queryset.filter(issue__target_date__gte=filters["target_date_from"])
|
|
if filters["target_date_to"]:
|
|
queryset = queryset.filter(issue__target_date__lte=filters["target_date_to"])
|
|
if filters["has_unread_updates"] is not None:
|
|
unread_request_ids = self.get_unread_request_ids(request.user)
|
|
if filters["has_unread_updates"]:
|
|
queryset = queryset.filter(pk__in=unread_request_ids or ["00000000-0000-0000-0000-000000000000"])
|
|
else:
|
|
queryset = queryset.exclude(pk__in=unread_request_ids)
|
|
|
|
sorting = self.get_sorting(request)
|
|
ordering = self.BOARD_ORDERING_MAP[sorting["order_by"]]
|
|
if sorting["sort_by"] == "desc":
|
|
ordering = f"-{ordering}"
|
|
|
|
return queryset.order_by(ordering).distinct()
|
|
|
|
def build_project_map(self, contour_requests):
|
|
project_ids = {
|
|
str(project_id)
|
|
for contour_request in contour_requests
|
|
for project_id in [
|
|
contour_request.extra.get("source_project_id"),
|
|
contour_request.extra.get("target_project_id") or (str(contour_request.issue.project_id) if contour_request.issue_id else None),
|
|
]
|
|
if project_id
|
|
}
|
|
|
|
if not project_ids:
|
|
return {}
|
|
|
|
return {
|
|
str(project.id): project
|
|
for project in Project.objects.filter(pk__in=project_ids)
|
|
}
|
|
|
|
def build_member_project_ids(self, request, contour_requests):
|
|
issue_project_ids = {
|
|
str(contour_request.issue.project_id)
|
|
for contour_request in contour_requests
|
|
if contour_request.issue_id and contour_request.issue and contour_request.issue.project_id
|
|
}
|
|
|
|
if not issue_project_ids:
|
|
return set()
|
|
|
|
return {
|
|
str(project_id)
|
|
for project_id in ProjectMember.objects.filter(
|
|
workspace__slug=self.kwargs.get("slug"),
|
|
member=request.user,
|
|
project_id__in=issue_project_ids,
|
|
is_active=True,
|
|
).values_list("project_id", flat=True)
|
|
}
|
|
|
|
def build_serializer_context(self, request, contour_requests, current_project_id, include_mirror_data=False):
|
|
contour_requests = list(contour_requests)
|
|
unread_request_ids = self.get_unread_request_ids(request.user, request_ids=[contour_request.id for contour_request in contour_requests])
|
|
return {
|
|
"include_mirror_data": include_mirror_data,
|
|
"workspace_slug": self.kwargs.get("slug"),
|
|
"source_project_id": str(current_project_id),
|
|
"current_project_id": str(current_project_id),
|
|
"project_map": self.build_project_map(contour_requests),
|
|
"member_project_ids": self.build_member_project_ids(request, contour_requests),
|
|
"unread_request_ids": unread_request_ids,
|
|
"request": request,
|
|
}
|
|
|
|
def mark_request_notifications_read(self, user, contour_request):
|
|
user_id = getattr(user, "id", None)
|
|
if not user_id:
|
|
return
|
|
|
|
Notification.objects.filter(
|
|
receiver_id=user_id,
|
|
sender__startswith="in_app:external_contours:",
|
|
read_at__isnull=True,
|
|
data__issue__id=str(contour_request.id),
|
|
).update(read_at=timezone.now())
|
|
|
|
|
|
class ExternalContourBoardEndpoint(ExternalContourReadMixin, BaseAPIView):
|
|
permission_classes = [ProjectLitePermission]
|
|
serializer_class = ExternalContourBoardItemSerializer
|
|
|
|
def get(self, request, slug, project_id):
|
|
requested_directions = self.get_requested_directions(request)
|
|
current_project_id = str(project_id)
|
|
|
|
outgoing_queryset = self.apply_board_filters(self.get_outgoing_queryset(), request, direction="outgoing")
|
|
incoming_queryset = self.apply_board_filters(self.get_incoming_queryset(), request, direction="incoming")
|
|
|
|
outgoing_requests = list(outgoing_queryset) if "outgoing" in requested_directions else []
|
|
incoming_requests = list(incoming_queryset) if "incoming" in requested_directions else []
|
|
|
|
outgoing_serializer = ExternalContourBoardItemSerializer(
|
|
outgoing_requests,
|
|
many=True,
|
|
context=self.build_serializer_context(request, outgoing_requests, current_project_id=current_project_id),
|
|
)
|
|
incoming_serializer = ExternalContourBoardItemSerializer(
|
|
incoming_requests,
|
|
many=True,
|
|
context=self.build_serializer_context(request, incoming_requests, current_project_id=current_project_id),
|
|
)
|
|
|
|
return Response(
|
|
{
|
|
"filters": self.get_applied_filters(request),
|
|
"sorting": self.get_sorting(request),
|
|
"columns": [
|
|
{
|
|
"key": "outgoing",
|
|
"title": "Исходящие",
|
|
"total_count": len(outgoing_requests),
|
|
"next_cursor": "",
|
|
"results": outgoing_serializer.data,
|
|
},
|
|
{
|
|
"key": "incoming",
|
|
"title": "Входящие",
|
|
"total_count": len(incoming_requests),
|
|
"next_cursor": "",
|
|
"results": incoming_serializer.data,
|
|
},
|
|
],
|
|
},
|
|
status=status.HTTP_200_OK,
|
|
)
|
|
|
|
|
|
class ExternalContourBoardItemDetailEndpoint(ExternalContourReadMixin, BaseAPIView):
|
|
permission_classes = [ProjectLitePermission]
|
|
serializer_class = ExternalContourBoardItemSerializer
|
|
|
|
def get(self, request, slug, project_id, request_id):
|
|
contour_request = get_object_or_404(self.get_board_item_queryset(), pk=request_id)
|
|
self.mark_request_notifications_read(request.user, contour_request)
|
|
|
|
serializer = ExternalContourBoardItemSerializer(
|
|
contour_request,
|
|
context=self.build_serializer_context(
|
|
request,
|
|
[contour_request],
|
|
current_project_id=str(project_id),
|
|
include_mirror_data=True,
|
|
),
|
|
)
|
|
return Response(serializer.data, status=status.HTTP_200_OK)
|
|
|
|
|
|
class ExternalContourDetailEndpoint(BaseAPIView):
|
|
permission_classes = [ProjectLitePermission]
|
|
serializer_class = ExternalContourRequestSerializer
|
|
|
|
def get_queryset(self):
|
|
return (
|
|
IntakeIssue.objects.filter(
|
|
workspace__slug=self.kwargs.get("slug"),
|
|
extra__bridge="external-contours",
|
|
extra__source_project_id=str(self.kwargs.get("project_id")),
|
|
pk=self.kwargs.get("request_id"),
|
|
)
|
|
.select_related(
|
|
"issue",
|
|
"issue__state",
|
|
"issue__project",
|
|
"issue__created_by",
|
|
)
|
|
.prefetch_related("issue__issue_assignee__assignee", "issue__label_issue__label")
|
|
)
|
|
|
|
def mark_request_notifications_read(self, user, contour_request):
|
|
user_id = getattr(user, "id", None)
|
|
if not user_id:
|
|
return
|
|
|
|
Notification.objects.filter(
|
|
receiver_id=user_id,
|
|
sender__startswith="in_app:external_contours:",
|
|
read_at__isnull=True,
|
|
data__issue__id=str(contour_request.id),
|
|
).update(read_at=timezone.now())
|
|
|
|
def get(self, request, slug, project_id, request_id):
|
|
contour_request = get_object_or_404(self.get_queryset())
|
|
self.mark_request_notifications_read(request.user, contour_request)
|
|
serializer = ExternalContourRequestSerializer(
|
|
contour_request,
|
|
context={
|
|
"include_mirror_data": True,
|
|
"workspace_slug": slug,
|
|
"source_project_id": str(project_id),
|
|
"request": request,
|
|
},
|
|
)
|
|
return Response(serializer.data, status=status.HTTP_200_OK)
|
|
|
|
def patch(self, request, slug, project_id, request_id):
|
|
contour_request = get_object_or_404(self.get_queryset())
|
|
issue = contour_request.issue
|
|
|
|
if not issue:
|
|
return Response({"error": "Target issue was not found"}, status=status.HTTP_404_NOT_FOUND)
|
|
|
|
requested_by_id = contour_request.extra.get("requested_by_id") or (
|
|
str(issue.created_by_id) if issue.created_by_id else None
|
|
)
|
|
if str(request.user.id) != str(requested_by_id):
|
|
return Response({"error": "Only the sender can edit this request"}, status=status.HTTP_403_FORBIDDEN)
|
|
|
|
if issue.state and issue.state.group in [StateGroup.COMPLETED.value, StateGroup.CANCELLED.value]:
|
|
return Response(
|
|
{"error": "Only open external contour requests can be edited"},
|
|
status=status.HTTP_400_BAD_REQUEST,
|
|
)
|
|
|
|
serializer = ExternalContourRequestUpdateSerializer(data=request.data)
|
|
serializer.is_valid(raise_exception=True)
|
|
issue_update_data = serializer.validated_data.copy()
|
|
changed_fields = list(issue_update_data.keys())
|
|
assignee_ids = issue_update_data.pop("assignee_ids", None)
|
|
label_ids = issue_update_data.pop("label_ids", None)
|
|
if assignee_ids is not None:
|
|
issue_update_data["assignees"] = assignee_ids
|
|
if label_ids is not None:
|
|
issue_update_data["labels"] = label_ids
|
|
|
|
issue_serializer = IssueCreateSerializer(
|
|
issue,
|
|
data=issue_update_data,
|
|
partial=True,
|
|
context={
|
|
"project_id": str(issue.project_id),
|
|
"workspace_id": str(issue.workspace_id),
|
|
},
|
|
)
|
|
issue_serializer.is_valid(raise_exception=True)
|
|
updated_issue = issue_serializer.save()
|
|
|
|
contour_request.updated_at = timezone.now()
|
|
contour_request.save(update_fields=["updated_at"])
|
|
contour_request.refresh_from_db()
|
|
publish_issue_event_on_commit(
|
|
"issue.updated",
|
|
updated_issue,
|
|
actor_id=request.user.id,
|
|
changed_fields=changed_fields,
|
|
publish_external_bridge=False,
|
|
)
|
|
publish_external_contour_event_on_commit(
|
|
"external_contour.updated",
|
|
contour_request,
|
|
actor_id=request.user.id,
|
|
changed_fields=changed_fields,
|
|
)
|
|
|
|
response_serializer = ExternalContourRequestSerializer(
|
|
contour_request,
|
|
context={
|
|
"include_mirror_data": True,
|
|
"workspace_slug": slug,
|
|
"source_project_id": str(project_id),
|
|
"request": request,
|
|
},
|
|
)
|
|
return Response(response_serializer.data, status=status.HTTP_200_OK)
|
|
|
|
def delete(self, request, slug, project_id, request_id):
|
|
contour_request = get_object_or_404(self.get_queryset())
|
|
issue = contour_request.issue
|
|
|
|
if not issue:
|
|
contour_request.delete()
|
|
return Response(status=status.HTTP_204_NO_CONTENT)
|
|
|
|
requested_by_id = contour_request.extra.get("requested_by_id") or (
|
|
str(issue.created_by_id) if issue.created_by_id else None
|
|
)
|
|
if str(request.user.id) != str(requested_by_id):
|
|
return Response({"error": "Only the sender can delete this request"}, status=status.HTTP_403_FORBIDDEN)
|
|
|
|
publish_external_contour_event_on_commit(
|
|
"external_contour.deleted",
|
|
contour_request,
|
|
actor_id=request.user.id,
|
|
changed_fields=["deleted_at"],
|
|
)
|
|
publish_issue_event_on_commit(
|
|
"issue.deleted",
|
|
issue,
|
|
actor_id=request.user.id,
|
|
changed_fields=["deleted_at", "external_contour"],
|
|
publish_external_bridge=False,
|
|
)
|
|
contour_request.delete()
|
|
issue.delete()
|
|
return Response(status=status.HTTP_204_NO_CONTENT)
|
|
|
|
|
|
class ExternalContourDecisionEndpoint(BaseAPIView):
|
|
permission_classes = [ProjectLitePermission]
|
|
serializer_class = ExternalContourRequestSerializer
|
|
|
|
def get_queryset(self):
|
|
return (
|
|
IntakeIssue.objects.filter(
|
|
workspace__slug=self.kwargs.get("slug"),
|
|
extra__bridge="external-contours",
|
|
extra__source_project_id=str(self.kwargs.get("project_id")),
|
|
pk=self.kwargs.get("request_id"),
|
|
)
|
|
.select_related(
|
|
"issue",
|
|
"issue__state",
|
|
"issue__project",
|
|
"issue__created_by",
|
|
)
|
|
.prefetch_related("issue__issue_assignee__assignee", "issue__label_issue__label")
|
|
)
|
|
|
|
def post(self, request, slug, project_id, request_id):
|
|
contour_request = get_object_or_404(self.get_queryset())
|
|
serializer = ExternalContourRequestDecisionSerializer(data=request.data)
|
|
serializer.is_valid(raise_exception=True)
|
|
|
|
action = serializer.validated_data["action"]
|
|
comment = (serializer.validated_data.get("comment") or "").strip()
|
|
issue = contour_request.issue
|
|
|
|
if not issue or not issue.state or issue.state.group not in [StateGroup.COMPLETED.value, StateGroup.CANCELLED.value]:
|
|
return Response(
|
|
{"error": "Source decision is available only after the target contour finishes processing"},
|
|
status=status.HTTP_400_BAD_REQUEST,
|
|
)
|
|
|
|
if action == "accept":
|
|
contour_request.extra = {
|
|
**contour_request.extra,
|
|
"source_decision": "accepted",
|
|
"source_decision_at": timezone.now().isoformat(),
|
|
"source_decision_by_name": request.user.display_name,
|
|
}
|
|
contour_request.save(update_fields=["extra", "updated_at"])
|
|
else:
|
|
target_default_state = (
|
|
State.objects.filter(project=issue.project, default=True)
|
|
.exclude(group=StateGroup.TRIAGE.value)
|
|
.first()
|
|
) or State.objects.filter(project=issue.project).exclude(group=StateGroup.TRIAGE.value).order_by(
|
|
"sequence", "created_at"
|
|
).first()
|
|
|
|
if not target_default_state:
|
|
return Response({"error": "Target project has no available workflow state"}, status=status.HTTP_400_BAD_REQUEST)
|
|
|
|
try:
|
|
create_external_contour_issue_comment(
|
|
issue=issue,
|
|
actor=request.user,
|
|
comment=comment,
|
|
origin=base_host(request=request, is_app=True),
|
|
)
|
|
except ValidationError as exc:
|
|
return Response({"error": exc.message_dict if hasattr(exc, "message_dict") else str(exc)}, status=status.HTTP_400_BAD_REQUEST)
|
|
|
|
issue.state = target_default_state
|
|
issue.save(update_fields=["state", "updated_at"])
|
|
publish_issue_event_on_commit(
|
|
"issue.updated",
|
|
issue,
|
|
actor_id=request.user.id,
|
|
changed_fields=["state", "external_contour_reopen"],
|
|
publish_external_bridge=False,
|
|
)
|
|
|
|
extra = dict(contour_request.extra or {})
|
|
extra.pop("source_decision", None)
|
|
extra.pop("source_decision_at", None)
|
|
extra.pop("source_decision_by_name", None)
|
|
extra["last_decline_comment"] = comment
|
|
extra["last_reopened_at"] = issue.updated_at.isoformat() if issue.updated_at else None
|
|
extra["last_reopened_by_name"] = request.user.display_name
|
|
contour_request.extra = extra
|
|
contour_request.save(update_fields=["extra", "updated_at"])
|
|
|
|
publish_external_contour_event_on_commit(
|
|
"external_contour.updated",
|
|
contour_request,
|
|
actor_id=request.user.id,
|
|
changed_fields=["source_decision", "state"],
|
|
)
|
|
|
|
contour_request.refresh_from_db()
|
|
Notification.objects.filter(
|
|
receiver_id=request.user.id,
|
|
sender__startswith="in_app:external_contours:",
|
|
read_at__isnull=True,
|
|
data__issue__id=str(contour_request.id),
|
|
).update(read_at=timezone.now())
|
|
serializer = ExternalContourRequestSerializer(
|
|
IntakeIssue.objects.select_related(
|
|
"issue",
|
|
"issue__state",
|
|
"issue__project",
|
|
"issue__created_by",
|
|
)
|
|
.prefetch_related("issue__issue_assignee__assignee", "issue__label_issue__label")
|
|
.get(pk=contour_request.id),
|
|
context={
|
|
"include_mirror_data": True,
|
|
"workspace_slug": slug,
|
|
"source_project_id": str(project_id),
|
|
"request": request,
|
|
},
|
|
)
|
|
return Response(serializer.data, status=status.HTTP_200_OK)
|
|
|
|
|
|
class ExternalContourReplyEndpoint(BaseAPIView):
|
|
permission_classes = [ProjectLitePermission]
|
|
serializer_class = ExternalContourRequestSerializer
|
|
|
|
def get_queryset(self):
|
|
return (
|
|
IntakeIssue.objects.filter(
|
|
workspace__slug=self.kwargs.get("slug"),
|
|
extra__bridge="external-contours",
|
|
extra__source_project_id=str(self.kwargs.get("project_id")),
|
|
pk=self.kwargs.get("request_id"),
|
|
)
|
|
.select_related(
|
|
"issue",
|
|
"issue__state",
|
|
"issue__project",
|
|
"issue__created_by",
|
|
)
|
|
.prefetch_related("issue__issue_assignee__assignee", "issue__label_issue__label")
|
|
)
|
|
|
|
def post(self, request, slug, project_id, request_id):
|
|
contour_request = get_object_or_404(self.get_queryset())
|
|
serializer = ExternalContourRequestReplySerializer(data=request.data)
|
|
serializer.is_valid(raise_exception=True)
|
|
|
|
issue = contour_request.issue
|
|
if not issue:
|
|
return Response({"error": "Target issue was not found"}, status=status.HTTP_404_NOT_FOUND)
|
|
|
|
try:
|
|
create_external_contour_issue_comment(
|
|
issue=issue,
|
|
actor=request.user,
|
|
comment=serializer.validated_data["comment"],
|
|
origin=base_host(request=request, is_app=True),
|
|
)
|
|
except ValidationError as exc:
|
|
return Response({"error": exc.message_dict if hasattr(exc, "message_dict") else str(exc)}, status=status.HTTP_400_BAD_REQUEST)
|
|
|
|
contour_request.refresh_from_db()
|
|
publish_external_contour_event_on_commit(
|
|
"external_contour.updated",
|
|
contour_request,
|
|
actor_id=request.user.id,
|
|
changed_fields=["comments"],
|
|
)
|
|
Notification.objects.filter(
|
|
receiver_id=request.user.id,
|
|
sender__startswith="in_app:external_contours:",
|
|
read_at__isnull=True,
|
|
data__issue__id=str(contour_request.id),
|
|
).update(read_at=timezone.now())
|
|
response_serializer = ExternalContourRequestSerializer(
|
|
contour_request,
|
|
context={
|
|
"include_mirror_data": True,
|
|
"workspace_slug": slug,
|
|
"source_project_id": str(project_id),
|
|
"request": request,
|
|
},
|
|
)
|
|
return Response(response_serializer.data, status=status.HTTP_200_OK)
|
|
|
|
|
|
class ExternalContourAttachmentDownloadEndpoint(ExternalContourReadMixin, BaseAPIView):
|
|
permission_classes = [ProjectLitePermission]
|
|
|
|
def get_queryset(self):
|
|
return self.get_board_item_queryset().filter(pk=self.kwargs.get("request_id")).select_related(
|
|
"issue", "issue__project", "workspace"
|
|
)
|
|
|
|
def get(self, request, slug, project_id, request_id, attachment_id):
|
|
contour_request = get_object_or_404(self.get_queryset())
|
|
attachment = get_object_or_404(
|
|
FileAsset,
|
|
pk=attachment_id,
|
|
issue_id=contour_request.issue_id,
|
|
entity_type=FileAsset.EntityTypeContext.ISSUE_ATTACHMENT,
|
|
is_uploaded=True,
|
|
is_deleted=False,
|
|
)
|
|
|
|
storage = S3Storage(request=request)
|
|
presigned_url = storage.generate_presigned_url(
|
|
object_name=attachment.asset.name,
|
|
disposition="attachment",
|
|
filename=attachment.attributes.get("name"),
|
|
)
|
|
return HttpResponseRedirect(presigned_url)
|