feat: django-rest-framework

ietf/api/apps.py

@@ -13,3 +13,5 @@ def ready(self):
         https://docs.djangoproject.com/en/4.2/ref/applications/#django.apps.AppConfig.ready
         """
         populate_api_list()
+        # Import drf-spectacular extensions 
+        import ietf.api.schema  # noqa

ietf/api/authentication.py

@@ -0,0 +1,19 @@
+# Copyright The IETF Trust 2024, All Rights Reserved
+#
+from rest_framework import authentication
+from django.contrib.auth.models import AnonymousUser
+
+
+class ApiKeyAuthentication(authentication.BaseAuthentication):
+    """API-Key header authentication"""
+
+    def authenticate(self, request):
+        """Extract the authentication token, if present
+        
+        This does not validate the token, it just arranges for it to be available in request.auth.
+        It's up to a Permissions class to validate it for the appropriate endpoint.
+        """
+        token = request.META.get("HTTP_X_API_KEY", None)
+        if token is None:
+            return None
+        return AnonymousUser(), token  # available as request.user and request.auth

ietf/api/permissions.py

@@ -0,0 +1,18 @@
+# Copyright The IETF Trust 2024, All Rights Reserved
+#
+import rest_framework.permissions
+from ietf.api.ietf_utils import is_valid_token
+
+
+class ApiKeyEndpointPermissions(rest_framework.permissions.BasePermission):
+    """Permissions class that validates a token using is_valid_token
+
+    The view class must indicate the relevant endpoint by setting `api_key_endpoint`.
+    Must be used with an Authentication class that puts a token in request.auth.
+    """
+    def has_permission(self, request, view):
+        endpoint = getattr(view, "api_key_endpoint", None)
+        auth_token = getattr(request, "auth", None)
+        if endpoint is not None and auth_token is not None:
+            return is_valid_token(endpoint, auth_token)
+        return False

ietf/api/schema.py

@@ -0,0 +1,20 @@
+# Copyright The IETF Trust 2024, All Rights Reserved
+#
+from drf_spectacular.extensions import OpenApiAuthenticationExtension
+
+
+class ApiKeyAuthenticationScheme(OpenApiAuthenticationExtension):
+    """Authentication scheme extension for the ApiKeyAuthentication
+
+    Used by drf-spectacular when rendering the OpenAPI schema
+    """
+    target_class = "ietf.api.authentication.ApiKeyAuthentication"
+    name = "apiKeyAuth"
+
+    def get_security_definition(self, auto_schema):
+        return {
+            "type": "apiKey",
+            "description": "Shared secret in the X-Api-Key header",
+            "name": "X-Api-Key",
+            "in": "header",
+        }

ietf/api/serializers_rpc.py

@@ -0,0 +1,150 @@
+# Copyright The IETF Trust 2024, All Rights Reserved
+#
+import datetime
+from typing import Literal, Optional
+
+from drf_spectacular.types import OpenApiTypes
+from drf_spectacular.utils import extend_schema_field
+from rest_framework import serializers
+
+from ietf.doc.models import DocumentAuthor, Document
+from ietf.person.models import Person
+
+
+class PersonBatchSerializer(serializers.Serializer):
+    person_ids = serializers.ListField(child=serializers.IntegerField())
+
+
+class PersonSerializer(serializers.ModelSerializer):
+    """Serializer for a Person in a response"""
+
+    plain_name = serializers.SerializerMethodField()
+
+    class Meta:
+        model = Person
+        fields = ["id", "plain_name"]
+
+    def get_plain_name(self, person) -> str:
+        return person.plain_name()
+
+
+class DocumentAuthorSerializer(serializers.ModelSerializer):
+    """Serializer for a DocumentAuthor in a response"""
+
+    plain_name = serializers.SerializerMethodField()
+
+    class Meta:
+        model = DocumentAuthor
+        fields = ["person", "plain_name"]
+
+    def get_plain_name(self, document_author: DocumentAuthor) -> str:
+        return document_author.person.plain_name()
+
+
+class FullDraftSerializer(serializers.ModelSerializer):
+    source_format = serializers.SerializerMethodField()
+    authors = DocumentAuthorSerializer(many=True, source="documentauthor_set")
+    shepherd = serializers.SerializerMethodField()
+
+    class Meta:
+        model = Document
+        fields = [
+            "id",
+            "name",
+            "rev",
+            "stream",
+            "title",
+            "pages",
+            "source_format",
+            "authors",
+            "shepherd",
+            "intended_std_level",
+        ]
+
+    def get_source_format(
+        self, doc: Document
+    ) -> Literal["unknown", "xml-v2", "xml-v3", "txt"]:
+        submission = doc.submission()
+        if submission is None:
+            return "unknown"
+        if ".xml" in submission.file_types:
+            if submission.xml_version == "3":
+                return "xml-v3"
+            else:
+                return "xml-v2"
+        elif ".txt" in submission.file_types:
+            return "txt"
+        return "unknown"
+
+    @extend_schema_field(OpenApiTypes.EMAIL)
+    def get_shepherd(self, doc: Document) -> str:
+        if doc.shepherd:
+            return doc.shepherd.formatted_ascii_email()
+        return ""
+
+
+class DraftSerializer(FullDraftSerializer):
+    class Meta:
+        model = Document
+        fields = [
+            "id",
+            "name",
+            "rev",
+            "stream",
+            "title",
+            "pages",
+            "source_format",
+            "authors",
+        ]
+
+
+class SubmittedToQueueSerializer(FullDraftSerializer):
+    submitted = serializers.SerializerMethodField()
+
+    class Meta:
+        model = Document
+        fields = [
+            "id",
+            "name",
+            "stream",
+            "submitted",
+        ]
+
+    def get_submitted(self, doc) -> Optional[datetime.datetime]:
+        event = doc.sent_to_rfc_editor_event()
+        return None if event is None else event.time
+
+
+class OriginalStreamSerializer(serializers.ModelSerializer):
+    stream = serializers.CharField(read_only=True, source="orig_stream_id")
+
+    class Meta:
+        model = Document
+        fields = ["rfc_number", "stream"]
+
+
+class DemoPersonCreateSerializer(serializers.Serializer):
+    name = serializers.CharField(max_length=255)
+
+
+class DemoPersonSerializer(serializers.ModelSerializer):
+    person_pk = serializers.IntegerField(source="pk")
+
+    class Meta:
+        model = Person
+        fields = ["user_id", "person_pk"]
+
+
+class DemoDraftCreateSerializer(serializers.Serializer):
+    name = serializers.CharField(max_length=255, required=True)
+    stream_id = serializers.CharField(default="ietf")
+    rev = serializers.CharField(default=None)
+    states = serializers.DictField(child=serializers.CharField(), default=None)
+
+
+class DemoDraftSerializer(serializers.ModelSerializer):
+    doc_id = serializers.IntegerField(source="pk")
+
+    class Meta:
+        model = Document
+        fields = ["doc_id", "name"]

ietf/api/urls_rpc.py

@@ -1,19 +1,22 @@
 # Copyright The IETF Trust 2023-2024, All Rights Reserved
 
+from rest_framework import routers
+from django.urls import include, path
+
 from ietf.api import views_rpc
 
 from ietf.utils.urls import url
 
+router = routers.DefaultRouter()
+router.register(r"demo", views_rpc.DemoViewSet, basename="demo")
+router.register(r"draft", views_rpc.DraftViewSet, basename="draft")
+router.register(r"person", views_rpc.PersonViewSet)
+router.register(r"rfc", views_rpc.RfcViewSet, basename="rfc")
+
 urlpatterns = [
-    url(r"^doc/create_demo_draft/$", views_rpc.create_demo_draft),
-    url(r"^doc/drafts/(?P<doc_id>[0-9]+)$", views_rpc.rpc_draft),
-    url(r"^doc/drafts_by_names/", views_rpc.drafts_by_names),
-    url(r"^doc/submitted_to_rpc/$", views_rpc.submitted_to_rpc),
-    url(r"^doc/rfc/original_stream/$", views_rpc.rfc_original_stream),
+    url(r"^draft/by_names/", views_rpc.DraftsByNamesView.as_view()),
     url(r"^doc/rfc/authors/$", views_rpc.rfc_authors),
-    url(r"^person/create_demo_person/$", views_rpc.create_demo_person),
     url(r"^person/persons_by_email/$", views_rpc.persons_by_email),
-    url(r"^person/(?P<person_id>[0-9]+)$", views_rpc.rpc_person),
-    url(r"^persons/$", views_rpc.rpc_persons),
-    url(r"^subject/(?P<subject_id>[0-9]+)/person/$", views_rpc.rpc_subject_person),
+    path(r"subject/<str:subject_id>/person/", views_rpc.SubjectPersonView.as_view()),
+    path("", include(router.urls)),  # todo get rid of drf prefix when done converting
 ]