651 lines
22 KiB
Python
651 lines
22 KiB
Python
# Python imports
|
|
import json
|
|
|
|
# Django imports
|
|
from django.core import serializers
|
|
from django.db.models import Count, F, Func, OuterRef, Prefetch, Q
|
|
from django.utils import timezone
|
|
from django.core.serializers.json import DjangoJSONEncoder
|
|
|
|
# Third party imports
|
|
from rest_framework import status
|
|
from rest_framework.response import Response
|
|
|
|
# Module imports
|
|
from plane.api.serializers import (
|
|
IssueSerializer,
|
|
ModuleIssueSerializer,
|
|
ModuleSerializer,
|
|
)
|
|
from plane.app.permissions import ProjectEntityPermission
|
|
from plane.bgtasks.issue_activities_task import issue_activity
|
|
from plane.db.models import (
|
|
Issue,
|
|
IssueAttachment,
|
|
IssueLink,
|
|
Module,
|
|
ModuleIssue,
|
|
ModuleLink,
|
|
Project,
|
|
ProjectMember,
|
|
UserFavorite,
|
|
)
|
|
|
|
from .base import BaseAPIView
|
|
from plane.bgtasks.webhook_task import model_activity
|
|
|
|
|
|
class ModuleAPIEndpoint(BaseAPIView):
|
|
"""
|
|
This viewset automatically provides `list`, `create`, `retrieve`,
|
|
`update` and `destroy` actions related to module.
|
|
|
|
"""
|
|
|
|
model = Module
|
|
permission_classes = [
|
|
ProjectEntityPermission,
|
|
]
|
|
serializer_class = ModuleSerializer
|
|
webhook_event = "module"
|
|
|
|
def get_queryset(self):
|
|
return (
|
|
Module.objects.filter(project_id=self.kwargs.get("project_id"))
|
|
.filter(workspace__slug=self.kwargs.get("slug"))
|
|
.select_related("project")
|
|
.select_related("workspace")
|
|
.select_related("lead")
|
|
.prefetch_related("members")
|
|
.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,
|
|
),
|
|
distinct=True,
|
|
),
|
|
)
|
|
.annotate(
|
|
completed_issues=Count(
|
|
"issue_module__issue__state__group",
|
|
filter=Q(
|
|
issue_module__issue__state__group="completed",
|
|
issue_module__issue__archived_at__isnull=True,
|
|
issue_module__issue__is_draft=False,
|
|
),
|
|
distinct=True,
|
|
)
|
|
)
|
|
.annotate(
|
|
cancelled_issues=Count(
|
|
"issue_module__issue__state__group",
|
|
filter=Q(
|
|
issue_module__issue__state__group="cancelled",
|
|
issue_module__issue__archived_at__isnull=True,
|
|
issue_module__issue__is_draft=False,
|
|
),
|
|
distinct=True,
|
|
)
|
|
)
|
|
.annotate(
|
|
started_issues=Count(
|
|
"issue_module__issue__state__group",
|
|
filter=Q(
|
|
issue_module__issue__state__group="started",
|
|
issue_module__issue__archived_at__isnull=True,
|
|
issue_module__issue__is_draft=False,
|
|
),
|
|
distinct=True,
|
|
)
|
|
)
|
|
.annotate(
|
|
unstarted_issues=Count(
|
|
"issue_module__issue__state__group",
|
|
filter=Q(
|
|
issue_module__issue__state__group="unstarted",
|
|
issue_module__issue__archived_at__isnull=True,
|
|
issue_module__issue__is_draft=False,
|
|
),
|
|
distinct=True,
|
|
)
|
|
)
|
|
.annotate(
|
|
backlog_issues=Count(
|
|
"issue_module__issue__state__group",
|
|
filter=Q(
|
|
issue_module__issue__state__group="backlog",
|
|
issue_module__issue__archived_at__isnull=True,
|
|
issue_module__issue__is_draft=False,
|
|
),
|
|
distinct=True,
|
|
)
|
|
)
|
|
.order_by(self.kwargs.get("order_by", "-created_at"))
|
|
)
|
|
|
|
def post(self, request, slug, project_id):
|
|
project = Project.objects.get(pk=project_id, workspace__slug=slug)
|
|
serializer = ModuleSerializer(
|
|
data=request.data,
|
|
context={
|
|
"project_id": project_id,
|
|
"workspace_id": project.workspace_id,
|
|
},
|
|
)
|
|
if serializer.is_valid():
|
|
if (
|
|
request.data.get("external_id")
|
|
and request.data.get("external_source")
|
|
and Module.objects.filter(
|
|
project_id=project_id,
|
|
workspace__slug=slug,
|
|
external_source=request.data.get("external_source"),
|
|
external_id=request.data.get("external_id"),
|
|
).exists()
|
|
):
|
|
module = Module.objects.filter(
|
|
project_id=project_id,
|
|
workspace__slug=slug,
|
|
external_source=request.data.get("external_source"),
|
|
external_id=request.data.get("external_id"),
|
|
).first()
|
|
return Response(
|
|
{
|
|
"error": "Module with the same external id and external source already exists",
|
|
"id": str(module.id),
|
|
},
|
|
status=status.HTTP_409_CONFLICT,
|
|
)
|
|
serializer.save()
|
|
# Send the model activity
|
|
model_activity.delay(
|
|
model_name="module",
|
|
model_id=str(serializer.data["id"]),
|
|
requested_data=request.data,
|
|
current_instance=None,
|
|
actor_id=request.user.id,
|
|
slug=slug,
|
|
origin=request.META.get("HTTP_ORIGIN"),
|
|
)
|
|
module = Module.objects.get(pk=serializer.data["id"])
|
|
serializer = ModuleSerializer(module)
|
|
return Response(serializer.data, status=status.HTTP_201_CREATED)
|
|
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
|
|
|
|
def patch(self, request, slug, project_id, pk):
|
|
module = Module.objects.get(
|
|
pk=pk, project_id=project_id, workspace__slug=slug
|
|
)
|
|
|
|
current_instance = json.dumps(
|
|
ModuleSerializer(module).data, cls=DjangoJSONEncoder
|
|
)
|
|
|
|
if module.archived_at:
|
|
return Response(
|
|
{"error": "Archived module cannot be edited"},
|
|
status=status.HTTP_400_BAD_REQUEST,
|
|
)
|
|
serializer = ModuleSerializer(
|
|
module,
|
|
data=request.data,
|
|
context={"project_id": project_id},
|
|
partial=True,
|
|
)
|
|
if serializer.is_valid():
|
|
if (
|
|
request.data.get("external_id")
|
|
and (module.external_id != request.data.get("external_id"))
|
|
and Module.objects.filter(
|
|
project_id=project_id,
|
|
workspace__slug=slug,
|
|
external_source=request.data.get(
|
|
"external_source", module.external_source
|
|
),
|
|
external_id=request.data.get("external_id"),
|
|
).exists()
|
|
):
|
|
return Response(
|
|
{
|
|
"error": "Module with the same external id and external source already exists",
|
|
"id": str(module.id),
|
|
},
|
|
status=status.HTTP_409_CONFLICT,
|
|
)
|
|
serializer.save()
|
|
|
|
# Send the model activity
|
|
model_activity.delay(
|
|
model_name="module",
|
|
model_id=str(serializer.data["id"]),
|
|
requested_data=request.data,
|
|
current_instance=current_instance,
|
|
actor_id=request.user.id,
|
|
slug=slug,
|
|
origin=request.META.get("HTTP_ORIGIN"),
|
|
)
|
|
|
|
return Response(serializer.data, status=status.HTTP_200_OK)
|
|
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
|
|
|
|
def get(self, request, slug, project_id, pk=None):
|
|
if pk:
|
|
queryset = (
|
|
self.get_queryset().filter(archived_at__isnull=True).get(pk=pk)
|
|
)
|
|
data = ModuleSerializer(
|
|
queryset,
|
|
fields=self.fields,
|
|
expand=self.expand,
|
|
).data
|
|
return Response(
|
|
data,
|
|
status=status.HTTP_200_OK,
|
|
)
|
|
return self.paginate(
|
|
request=request,
|
|
queryset=(self.get_queryset().filter(archived_at__isnull=True)),
|
|
on_results=lambda modules: ModuleSerializer(
|
|
modules,
|
|
many=True,
|
|
fields=self.fields,
|
|
expand=self.expand,
|
|
).data,
|
|
)
|
|
|
|
def delete(self, request, slug, project_id, pk):
|
|
module = Module.objects.get(
|
|
workspace__slug=slug, project_id=project_id, pk=pk
|
|
)
|
|
if module.created_by_id != request.user.id and (
|
|
not ProjectMember.objects.filter(
|
|
workspace__slug=slug,
|
|
member=request.user,
|
|
role=20,
|
|
project_id=project_id,
|
|
is_active=True,
|
|
).exists()
|
|
):
|
|
return Response(
|
|
{"error": "Only admin or creator can delete the module"},
|
|
status=status.HTTP_403_FORBIDDEN,
|
|
)
|
|
|
|
module_issues = list(
|
|
ModuleIssue.objects.filter(module_id=pk).values_list(
|
|
"issue", flat=True
|
|
)
|
|
)
|
|
issue_activity.delay(
|
|
type="module.activity.deleted",
|
|
requested_data=json.dumps(
|
|
{
|
|
"module_id": str(pk),
|
|
"module_name": str(module.name),
|
|
"issues": [str(issue_id) for issue_id in module_issues],
|
|
}
|
|
),
|
|
actor_id=str(request.user.id),
|
|
issue_id=None,
|
|
project_id=str(project_id),
|
|
current_instance=None,
|
|
epoch=int(timezone.now().timestamp()),
|
|
)
|
|
module.delete()
|
|
# Delete the module issues
|
|
ModuleIssue.objects.filter(
|
|
module=pk,
|
|
project_id=project_id,
|
|
).delete()
|
|
# Delete the user favorite module
|
|
UserFavorite.objects.filter(
|
|
entity_type="module",
|
|
entity_identifier=pk,
|
|
project_id=project_id,
|
|
).delete()
|
|
return Response(status=status.HTTP_204_NO_CONTENT)
|
|
|
|
|
|
class ModuleIssueAPIEndpoint(BaseAPIView):
|
|
"""
|
|
This viewset automatically provides `list`, `create`, `retrieve`,
|
|
`update` and `destroy` actions related to module issues.
|
|
|
|
"""
|
|
|
|
serializer_class = ModuleIssueSerializer
|
|
model = ModuleIssue
|
|
webhook_event = "module_issue"
|
|
bulk = True
|
|
|
|
permission_classes = [
|
|
ProjectEntityPermission,
|
|
]
|
|
|
|
def get_queryset(self):
|
|
return (
|
|
ModuleIssue.objects.annotate(
|
|
sub_issues_count=Issue.issue_objects.filter(
|
|
parent=OuterRef("issue")
|
|
)
|
|
.order_by()
|
|
.annotate(count=Func(F("id"), function="Count"))
|
|
.values("count")
|
|
)
|
|
.filter(workspace__slug=self.kwargs.get("slug"))
|
|
.filter(project_id=self.kwargs.get("project_id"))
|
|
.filter(module_id=self.kwargs.get("module_id"))
|
|
.filter(
|
|
project__project_projectmember__member=self.request.user,
|
|
project__project_projectmember__is_active=True,
|
|
)
|
|
.filter(project__archived_at__isnull=True)
|
|
.select_related("project")
|
|
.select_related("workspace")
|
|
.select_related("module")
|
|
.select_related("issue", "issue__state", "issue__project")
|
|
.prefetch_related("issue__assignees", "issue__labels")
|
|
.prefetch_related("module__members")
|
|
.order_by(self.kwargs.get("order_by", "-created_at"))
|
|
.distinct()
|
|
)
|
|
|
|
def get(self, request, slug, project_id, module_id):
|
|
order_by = request.GET.get("order_by", "created_at")
|
|
issues = (
|
|
Issue.issue_objects.filter(issue_module__module_id=module_id)
|
|
.annotate(
|
|
sub_issues_count=Issue.issue_objects.filter(
|
|
parent=OuterRef("id")
|
|
)
|
|
.order_by()
|
|
.annotate(count=Func(F("id"), function="Count"))
|
|
.values("count")
|
|
)
|
|
.annotate(bridge_id=F("issue_module__id"))
|
|
.filter(project_id=project_id)
|
|
.filter(workspace__slug=slug)
|
|
.select_related("project")
|
|
.select_related("workspace")
|
|
.select_related("state")
|
|
.select_related("parent")
|
|
.prefetch_related("assignees")
|
|
.prefetch_related("labels")
|
|
.order_by(order_by)
|
|
.annotate(
|
|
link_count=IssueLink.objects.filter(issue=OuterRef("id"))
|
|
.order_by()
|
|
.annotate(count=Func(F("id"), function="Count"))
|
|
.values("count")
|
|
)
|
|
.annotate(
|
|
attachment_count=IssueAttachment.objects.filter(
|
|
issue=OuterRef("id")
|
|
)
|
|
.order_by()
|
|
.annotate(count=Func(F("id"), function="Count"))
|
|
.values("count")
|
|
)
|
|
)
|
|
return self.paginate(
|
|
request=request,
|
|
queryset=(issues),
|
|
on_results=lambda issues: IssueSerializer(
|
|
issues,
|
|
many=True,
|
|
fields=self.fields,
|
|
expand=self.expand,
|
|
).data,
|
|
)
|
|
|
|
def post(self, request, slug, project_id, module_id):
|
|
issues = request.data.get("issues", [])
|
|
if not len(issues):
|
|
return Response(
|
|
{"error": "Issues are required"},
|
|
status=status.HTTP_400_BAD_REQUEST,
|
|
)
|
|
module = Module.objects.get(
|
|
workspace__slug=slug, project_id=project_id, pk=module_id
|
|
)
|
|
|
|
issues = Issue.objects.filter(
|
|
workspace__slug=slug, project_id=project_id, pk__in=issues
|
|
).values_list("id", flat=True)
|
|
|
|
module_issues = list(ModuleIssue.objects.filter(issue_id__in=issues))
|
|
|
|
update_module_issue_activity = []
|
|
records_to_update = []
|
|
record_to_create = []
|
|
|
|
for issue in issues:
|
|
module_issue = [
|
|
module_issue
|
|
for module_issue in module_issues
|
|
if str(module_issue.issue_id) in issues
|
|
]
|
|
|
|
if len(module_issue):
|
|
if module_issue[0].module_id != module_id:
|
|
update_module_issue_activity.append(
|
|
{
|
|
"old_module_id": str(module_issue[0].module_id),
|
|
"new_module_id": str(module_id),
|
|
"issue_id": str(module_issue[0].issue_id),
|
|
}
|
|
)
|
|
module_issue[0].module_id = module_id
|
|
records_to_update.append(module_issue[0])
|
|
else:
|
|
record_to_create.append(
|
|
ModuleIssue(
|
|
module=module,
|
|
issue_id=issue,
|
|
project_id=project_id,
|
|
workspace=module.workspace,
|
|
created_by=request.user,
|
|
updated_by=request.user,
|
|
)
|
|
)
|
|
|
|
ModuleIssue.objects.bulk_create(
|
|
record_to_create,
|
|
batch_size=10,
|
|
ignore_conflicts=True,
|
|
)
|
|
|
|
ModuleIssue.objects.bulk_update(
|
|
records_to_update,
|
|
["module"],
|
|
batch_size=10,
|
|
)
|
|
|
|
# Capture Issue Activity
|
|
issue_activity.delay(
|
|
type="module.activity.created",
|
|
requested_data=json.dumps({"modules_list": str(issues)}),
|
|
actor_id=str(self.request.user.id),
|
|
issue_id=None,
|
|
project_id=str(self.kwargs.get("project_id", None)),
|
|
current_instance=json.dumps(
|
|
{
|
|
"updated_module_issues": update_module_issue_activity,
|
|
"created_module_issues": serializers.serialize(
|
|
"json", record_to_create
|
|
),
|
|
}
|
|
),
|
|
epoch=int(timezone.now().timestamp()),
|
|
)
|
|
|
|
return Response(
|
|
ModuleIssueSerializer(self.get_queryset(), many=True).data,
|
|
status=status.HTTP_200_OK,
|
|
)
|
|
|
|
def delete(self, request, slug, project_id, module_id, issue_id):
|
|
module_issue = ModuleIssue.objects.get(
|
|
workspace__slug=slug,
|
|
project_id=project_id,
|
|
module_id=module_id,
|
|
issue_id=issue_id,
|
|
)
|
|
module_issue.delete()
|
|
issue_activity.delay(
|
|
type="module.activity.deleted",
|
|
requested_data=json.dumps(
|
|
{
|
|
"module_id": str(module_id),
|
|
"issues": [str(module_issue.issue_id)],
|
|
}
|
|
),
|
|
actor_id=str(request.user.id),
|
|
issue_id=str(issue_id),
|
|
project_id=str(project_id),
|
|
current_instance=None,
|
|
epoch=int(timezone.now().timestamp()),
|
|
)
|
|
return Response(status=status.HTTP_204_NO_CONTENT)
|
|
|
|
|
|
class ModuleArchiveUnarchiveAPIEndpoint(BaseAPIView):
|
|
permission_classes = [
|
|
ProjectEntityPermission,
|
|
]
|
|
|
|
def get_queryset(self):
|
|
return (
|
|
Module.objects.filter(project_id=self.kwargs.get("project_id"))
|
|
.filter(workspace__slug=self.kwargs.get("slug"))
|
|
.filter(archived_at__isnull=False)
|
|
.select_related("project")
|
|
.select_related("workspace")
|
|
.select_related("lead")
|
|
.prefetch_related("members")
|
|
.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,
|
|
),
|
|
distinct=True,
|
|
),
|
|
)
|
|
.annotate(
|
|
completed_issues=Count(
|
|
"issue_module__issue__state__group",
|
|
filter=Q(
|
|
issue_module__issue__state__group="completed",
|
|
issue_module__issue__archived_at__isnull=True,
|
|
issue_module__issue__is_draft=False,
|
|
),
|
|
distinct=True,
|
|
)
|
|
)
|
|
.annotate(
|
|
cancelled_issues=Count(
|
|
"issue_module__issue__state__group",
|
|
filter=Q(
|
|
issue_module__issue__state__group="cancelled",
|
|
issue_module__issue__archived_at__isnull=True,
|
|
issue_module__issue__is_draft=False,
|
|
),
|
|
distinct=True,
|
|
)
|
|
)
|
|
.annotate(
|
|
started_issues=Count(
|
|
"issue_module__issue__state__group",
|
|
filter=Q(
|
|
issue_module__issue__state__group="started",
|
|
issue_module__issue__archived_at__isnull=True,
|
|
issue_module__issue__is_draft=False,
|
|
),
|
|
distinct=True,
|
|
)
|
|
)
|
|
.annotate(
|
|
unstarted_issues=Count(
|
|
"issue_module__issue__state__group",
|
|
filter=Q(
|
|
issue_module__issue__state__group="unstarted",
|
|
issue_module__issue__archived_at__isnull=True,
|
|
issue_module__issue__is_draft=False,
|
|
),
|
|
distinct=True,
|
|
)
|
|
)
|
|
.annotate(
|
|
backlog_issues=Count(
|
|
"issue_module__issue__state__group",
|
|
filter=Q(
|
|
issue_module__issue__state__group="backlog",
|
|
issue_module__issue__archived_at__isnull=True,
|
|
issue_module__issue__is_draft=False,
|
|
),
|
|
distinct=True,
|
|
)
|
|
)
|
|
.order_by(self.kwargs.get("order_by", "-created_at"))
|
|
)
|
|
|
|
def get(self, request, slug, project_id, pk):
|
|
return self.paginate(
|
|
request=request,
|
|
queryset=(self.get_queryset()),
|
|
on_results=lambda modules: ModuleSerializer(
|
|
modules,
|
|
many=True,
|
|
fields=self.fields,
|
|
expand=self.expand,
|
|
).data,
|
|
)
|
|
|
|
def post(self, request, slug, project_id, pk):
|
|
module = Module.objects.get(
|
|
pk=pk, project_id=project_id, workspace__slug=slug
|
|
)
|
|
if module.status not in ["completed", "cancelled"]:
|
|
return Response(
|
|
{
|
|
"error": "Only completed or cancelled modules can be archived"
|
|
},
|
|
status=status.HTTP_400_BAD_REQUEST,
|
|
)
|
|
module.archived_at = timezone.now()
|
|
module.save()
|
|
UserFavorite.objects.filter(
|
|
entity_type="module",
|
|
entity_identifier=pk,
|
|
project_id=project_id,
|
|
workspace__slug=slug,
|
|
).delete()
|
|
return Response(status=status.HTTP_204_NO_CONTENT)
|
|
|
|
def delete(self, request, slug, project_id, pk):
|
|
module = Module.objects.get(
|
|
pk=pk, project_id=project_id, workspace__slug=slug
|
|
)
|
|
module.archived_at = None
|
|
module.save()
|
|
return Response(status=status.HTTP_204_NO_CONTENT)
|