feat: added external api endpoints for creating users and adding attachments to issues

apiserver/plane/api/urls/__init__.py

@@ -4,6 +4,7 @@
 from .cycle import urlpatterns as cycle_patterns
 from .module import urlpatterns as module_patterns
 from .inbox import urlpatterns as inbox_patterns
+from .member import urlpatterns as member_patterns
 
 urlpatterns = [
     *project_patterns,
@@ -12,4 +13,5 @@
     *cycle_patterns,
     *module_patterns,
     *inbox_patterns,
+    *member_patterns,
 ]

apiserver/plane/api/urls/issue.py

@@ -7,6 +7,7 @@
     IssueCommentAPIEndpoint,
     IssueActivityAPIEndpoint,
     WorkspaceIssueAPIEndpoint,
+    IssueAttachmentEndpoint,
 )
 
 urlpatterns = [
@@ -65,4 +66,9 @@
         IssueActivityAPIEndpoint.as_view(),
         name="activity",
     ),
+    path(
+        "workspaces/<str:slug>/projects/<uuid:project_id>/issues/<uuid:issue_id>/issue-attachments/",
+        IssueAttachmentEndpoint.as_view(),
+        name="attachment",
+    ),
 ]

apiserver/plane/api/urls/member.py

@@ -0,0 +1,13 @@
+from django.urls import path
+
+from plane.api.views import (
+    WorkspaceMemberAPIEndpoint,
+)
+
+urlpatterns = [
+    path(
+        "workspaces/<str:slug>/members/",
+        WorkspaceMemberAPIEndpoint.as_view(),
+        name="users",
+    ),
+]

apiserver/plane/api/views/__init__.py

@@ -9,6 +9,7 @@
     IssueLinkAPIEndpoint,
     IssueCommentAPIEndpoint,
     IssueActivityAPIEndpoint,
+    IssueAttachmentEndpoint,
 )
 
 from .cycle import (
@@ -24,4 +25,6 @@
     ModuleArchiveUnarchiveAPIEndpoint,
 )
 
+from .member import WorkspaceMemberAPIEndpoint
+
 from .inbox import InboxIssueAPIEndpoint

apiserver/plane/api/views/cycle.py

@@ -393,7 +393,6 @@ def delete(self, request, slug, project_id, pk):
 
 
 class CycleArchiveUnarchiveAPIEndpoint(BaseAPIView):
-
     permission_classes = [
         ProjectEntityPermission,
     ]
@@ -647,17 +646,6 @@ def post(self, request, slug, project_id, cycle_id):
             workspace__slug=slug, project_id=project_id, pk=cycle_id
         )
 
-        if (
-            cycle.end_date is not None
-            and cycle.end_date < timezone.now().date()
-        ):
-            return Response(
-                {
-                    "error": "The Cycle has already been completed so no new issues can be added"
-                },
-                status=status.HTTP_400_BAD_REQUEST,
-            )
-
         issues = Issue.objects.filter(
             pk__in=issues, workspace__slug=slug, project_id=project_id
         ).values_list("id", flat=True)

apiserver/plane/api/views/issue.py

@@ -22,9 +22,11 @@
 # Third party imports
 from rest_framework import status
 from rest_framework.response import Response
+from rest_framework.parsers import MultiPartParser, FormParser
 
 # Module imports
 from plane.api.serializers import (
+    IssueAttachmentSerializer,
     IssueActivitySerializer,
     IssueCommentSerializer,
     IssueLinkSerializer,
@@ -874,3 +876,83 @@ def get(self, request, slug, project_id, issue_id, pk=None):
                 expand=self.expand,
             ).data,
         )
+
+
+class IssueAttachmentEndpoint(BaseAPIView):
+    serializer_class = IssueAttachmentSerializer
+    permission_classes = [
+        ProjectEntityPermission,
+    ]
+    model = IssueAttachment
+    parser_classes = (MultiPartParser, FormParser)
+
+    def post(self, request, slug, project_id, issue_id):
+        serializer = IssueAttachmentSerializer(data=request.data)
+        if (
+            request.data.get("external_id")
+            and request.data.get("external_source")
+            and IssueAttachment.objects.filter(
+                project_id=project_id,
+                workspace__slug=slug,
+                issue_id=issue_id,
+                external_source=request.data.get("external_source"),
+                external_id=request.data.get("external_id"),
+            ).exists()
+        ):
+            issue_attachment = IssueAttachment.objects.filter(
+                workspace__slug=slug,
+                project_id=project_id,
+                external_id=request.data.get("external_id"),
+                external_source=request.data.get("external_source"),
+            ).first()
+            return Response(
+                {
+                    "error": "Issue attachment with the same external id and external source already exists",
+                    "id": str(issue_attachment.id),
+                },
+                status=status.HTTP_409_CONFLICT,
+            )
+
+        if serializer.is_valid():
+            serializer.save(project_id=project_id, issue_id=issue_id)
+            issue_activity.delay(
+                type="attachment.activity.created",
+                requested_data=None,
+                actor_id=str(self.request.user.id),
+                issue_id=str(self.kwargs.get("issue_id", None)),
+                project_id=str(self.kwargs.get("project_id", None)),
+                current_instance=json.dumps(
+                    serializer.data,
+                    cls=DjangoJSONEncoder,
+                ),
+                epoch=int(timezone.now().timestamp()),
+                notification=True,
+                origin=request.META.get("HTTP_ORIGIN"),
+            )
+            return Response(serializer.data, status=status.HTTP_201_CREATED)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    def delete(self, request, slug, project_id, issue_id, pk):
+        issue_attachment = IssueAttachment.objects.get(pk=pk)
+        issue_attachment.asset.delete(save=False)
+        issue_attachment.delete()
+        issue_activity.delay(
+            type="attachment.activity.deleted",
+            requested_data=None,
+            actor_id=str(self.request.user.id),
+            issue_id=str(self.kwargs.get("issue_id", None)),
+            project_id=str(self.kwargs.get("project_id", None)),
+            current_instance=None,
+            epoch=int(timezone.now().timestamp()),
+            notification=True,
+            origin=request.META.get("HTTP_ORIGIN"),
+        )
+
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+    def get(self, request, slug, project_id, issue_id):
+        issue_attachments = IssueAttachment.objects.filter(
+            issue_id=issue_id, workspace__slug=slug, project_id=project_id
+        )
+        serializer = IssueAttachmentSerializer(issue_attachments, many=True)
+        return Response(serializer.data, status=status.HTTP_200_OK)

apiserver/plane/api/views/member.py

@@ -0,0 +1,147 @@
+# Python imports
+import uuid
+
+# Django imports
+from django.contrib.auth.hashers import make_password
+from django.core.validators import validate_email
+from django.core.exceptions import ValidationError
+
+# Third Party imports
+from rest_framework.response import Response
+from rest_framework import status
+
+# Module imports
+from .base import BaseAPIView
+from plane.api.serializers import UserLiteSerializer
+from plane.db.models import (
+    User,
+    Workspace,
+    Project,
+    WorkspaceMember,
+    ProjectMember,
+)
+
+
+# API endpoint to get and insert users inside the workspace
+class WorkspaceMemberAPIEndpoint(BaseAPIView):
+    # Get all the users that are present inside the workspace
+    def get(self, request, slug):
+        # Check if the workspace exists
+        if not Workspace.objects.filter(slug=slug).exists():
+            return Response(
+                {"error": "Provided workspace does not exist"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # Get the workspace members that are present inside the workspace
+        workspace_members = WorkspaceMember.objects.filter(
+            workspace__slug=slug
+        )
+
+        # Get all the users that are present inside the workspace
+        users = UserLiteSerializer(
+            User.objects.filter(
+                id__in=workspace_members.values_list("member_id", flat=True)
+            ),
+            many=True,
+        ).data
+
+        return Response(users, status=status.HTTP_200_OK)
+
+    # Insert a new user inside the workspace, and assign the user to the project
+    def post(self, request, slug):
+        # Check if user with email already exists, and send bad request if it's
+        # not present, check for workspace and valid project mandat
+        # ------------------- Validation -------------------
+        if (
+            request.data.get("email") is None
+            or request.data.get("display_name") is None
+            or request.data.get("project_id") is None
+        ):
+            return Response(
+                {
+                    "error": "Expected email, display_name, workspace_slug, project_id, one or more of the fields are missing."
+                },
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        email = request.data.get("email")
+
+        try:
+            validate_email(email)
+        except ValidationError:
+            return Response(
+                {"error": "Invalid email provided"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        workspace = Workspace.objects.filter(slug=slug).first()
+        project = Project.objects.filter(
+            pk=request.data.get("project_id")
+        ).first()
+
+        if not all([workspace, project]):
+            return Response(
+                {"error": "Provided workspace or project does not exist"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # Check if user exists
+        user = User.objects.filter(email=email).first()
+        workspace_member = None
+        project_member = None
+
+        if user:
+            # Check if user is part of the workspace
+            workspace_member = WorkspaceMember.objects.filter(
+                workspace=workspace, member=user
+            ).first()
+            if workspace_member:
+                # Check if user is part of the project
+                project_member = ProjectMember.objects.filter(
+                    project=project, member=user
+                ).first()
+                if project_member:
+                    return Response(
+                        {
+                            "error": "User is already part of the workspace and project"
+                        },
+                        status=status.HTTP_400_BAD_REQUEST,
+                    )
+
+        # If user does not exist, create the user
+        if not user:
+            user = User.objects.create(
+                email=email,
+                display_name=request.data.get("display_name"),
+                first_name=request.data.get("first_name", ""),
+                last_name=request.data.get("last_name", ""),
+                username=uuid.uuid4().hex,
+                password=make_password(uuid.uuid4().hex),
+                is_password_autoset=True,
+                is_active=False,
+            )
+            user.save()
+
+        # Create a workspace member for the user if not already a member
+        if not workspace_member:
+            workspace_member = WorkspaceMember.objects.create(
+                workspace=workspace,
+                member=user,
+                role=request.data.get("role", 10),
+            )
+            workspace_member.save()
+
+        # Create a project member for the user if not already a member
+        if not project_member:
+            project_member = ProjectMember.objects.create(
+                project=project,
+                member=user,
+                role=request.data.get("role", 10),
+            )
+            project_member.save()
+
+        # Serialize the user and return the response
+        user_data = UserLiteSerializer(user).data
+
+        return Response(user_data, status=status.HTTP_201_CREATED)