# 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_activites_task import issue_activity from plane.db.models import ( Issue, IssueAttachment, IssueLink, Module, ModuleIssue, ModuleLink, Project, ) 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 ) 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() 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() 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)