267 lines
10 KiB
Python
267 lines
10 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.shortcuts import get_object_or_404
|
|
from rest_framework import status
|
|
from rest_framework.response import Response
|
|
|
|
from plane.api.serializers import (
|
|
ExternalContourRequestCreateSerializer,
|
|
ExternalContourRequestSerializer,
|
|
ExternalContourTargetOptionsSerializer,
|
|
ExternalContourTargetProjectSerializer,
|
|
)
|
|
from plane.api.serializers.issue import IssueSerializer as IssueCreateSerializer
|
|
from plane.app.permissions import ProjectLitePermission
|
|
from plane.app.views.base import BaseAPIView
|
|
from plane.db.models import Intake, IntakeIssue, Label, Project, ProjectMember, State, StateGroup
|
|
from plane.db.models.intake import IntakeIssueStatus, SourceType
|
|
|
|
|
|
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_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)
|
|
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 = (
|
|
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()
|
|
|
|
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()
|
|
|
|
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)
|
|
)
|
|
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")
|
|
|
|
serializer = ExternalContourTargetOptionsSerializer(
|
|
{
|
|
"project": target_project,
|
|
"member_ids": member_ids,
|
|
"labels": labels,
|
|
}
|
|
)
|
|
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 get(self, request, slug, project_id, request_id):
|
|
contour_request = get_object_or_404(self.get_queryset())
|
|
serializer = ExternalContourRequestSerializer(contour_request)
|
|
return Response(serializer.data, status=status.HTTP_200_OK)
|