feat: RPC modernization APIs

dev/build/migration-start.sh

@@ -3,7 +3,11 @@
 echo "Running Datatracker migrations..."
 ./ietf/manage.py migrate --settings=settings_local
 
-echo "Running Blobdb migrations ..."
-./ietf/manage.py migrate --settings=settings_local --database=blobdb
+# Check whether the blobdb database exists - inspectdb will return a false
+# status if not.
+if ./ietf/manage.py inspectdb --database blobdb > /dev/null 2>&1; then
+    echo "Running Blobdb migrations ..."
+    ./ietf/manage.py migrate --settings=settings_local --database=blobdb
+fi
 
 echo "Done!"

dev/deploy-to-container/settings_local.py

@@ -71,11 +71,10 @@
 
 DE_GFM_BINARY = '/usr/local/bin/de-gfm'
 
-# No real secrets here, these are public testing values _only_
 APP_API_TOKENS = {
-  "ietf.api.views.ingest_email_test": ["ingestion-test-token"]
+  "ietf.api.views.ingest_email_test": ["ingestion-test-token"],  # Not a real secret
+  "ietf.api.views_rpc" : ["devtoken"],  # For RPC dev work only, remove before merging to main!!!
 }
 
-
 # OIDC configuration
 SITE_URL = 'https://__HOSTNAME__'

docker/configs/settings_local.py

@@ -100,3 +100,7 @@
             bucket_name=f"{storagename}",
         ),
     }
+
+APP_API_TOKENS = {
+    "ietf.api.views_rpc" : ["devtoken"],
+}

ietf/api/serializers_rpc.py

@@ -0,0 +1,194 @@
+# Copyright The IETF Trust 2025, All Rights Reserved
+import datetime
+from typing import Literal, Optional
+
+from django.urls import reverse as urlreverse
+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.doc.utils import default_consensus
+from ietf.person.models import Person
+
+
+class PersonSerializer(serializers.ModelSerializer):
+    email = serializers.EmailField(read_only=True)
+    picture = serializers.URLField(source="cdn_photo_url", read_only=True)
+    url = serializers.SerializerMethodField(
+        help_text="relative URL for datatracker person page"
+    )
+
+    class Meta:
+        model = Person
+        fields = ["id", "plain_name", "email", "picture", "url"]
+        read_only_fields = ["id", "plain_name", "email", "picture", "url"]
+
+    @extend_schema_field(OpenApiTypes.URI)
+    def get_url(self, object: Person):
+        return urlreverse(
+            "ietf.person.views.profile",
+            kwargs={"email_or_name": object.email_address() or object.name},
+        )
+
+
+class EmailPersonSerializer(serializers.Serializer):
+    email = serializers.EmailField(source="address")
+    person_pk = serializers.IntegerField(source="person.pk")
+    name = serializers.CharField(source="person.name")
+    last_name = serializers.CharField(source="person.last_name")
+    initials = serializers.CharField(source="person.initials")
+
+
+class LowerCaseEmailField(serializers.EmailField):
+    def to_representation(self, value):
+        return super().to_representation(value).lower()
+
+
+class AuthorPersonSerializer(serializers.ModelSerializer):
+    person_pk = serializers.IntegerField(source="pk", read_only=True)
+    last_name = serializers.CharField()
+    initials = serializers.CharField()
+    email_addresses = serializers.ListField(
+        source="email_set.all", child=LowerCaseEmailField()
+    )
+
+    class Meta:
+        model = Person
+        fields = ["person_pk", "name", "last_name", "initials", "email_addresses"]
+
+
+class RfcWithAuthorsSerializer(serializers.ModelSerializer):
+    authors = AuthorPersonSerializer(many=True)
+
+    class Meta:
+        model = Document
+        fields = ["rfc_number", "authors"]
+
+
+class DraftWithAuthorsSerializer(serializers.ModelSerializer):
+    draft_name = serializers.CharField(source="name")
+    authors = AuthorPersonSerializer(many=True)
+
+    class Meta:
+        model = Document
+        fields = ["draft_name", "authors"]
+
+
+class DocumentAuthorSerializer(serializers.ModelSerializer):
+    """Serializer for a Person 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):
+    # Redefine these fields so they don't pick up the regex validator patterns.
+    # There seem to be some non-compliant drafts in the system! If this serializer
+    # is used for a writeable view, the validation will need to be added back.
+    name = serializers.CharField(max_length=255)
+    title = serializers.CharField(max_length=255)
+
+    # Other fields we need to add / adjust
+    source_format = serializers.SerializerMethodField()
+    authors = DocumentAuthorSerializer(many=True, source="documentauthor_set")
+    shepherd = serializers.SerializerMethodField()
+    consensus = serializers.SerializerMethodField()
+
+    class Meta:
+        model = Document
+        fields = [
+            "id",
+            "name",
+            "rev",
+            "stream",
+            "title",
+            "pages",
+            "source_format",
+            "authors",
+            "shepherd",
+            "intended_std_level",
+            "consensus",
+        ]
+
+    def get_consensus(self, doc: Document) -> Optional[bool]:
+        return default_consensus(doc)
+
+    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()
+    consensus = serializers.SerializerMethodField()
+
+    class Meta:
+        model = Document
+        fields = [
+            "id",
+            "name",
+            "stream",
+            "submitted",
+            "consensus",
+        ]
+
+    def get_submitted(self, doc) -> Optional[datetime.datetime]:
+        event = doc.sent_to_rfc_editor_event()
+        return None if event is None else event.time
+
+    def get_consensus(self, doc) -> Optional[bool]:
+        return default_consensus(doc)
+
+
+class OriginalStreamSerializer(serializers.ModelSerializer):
+    stream = serializers.CharField(read_only=True, source="orig_stream_id")
+
+    class Meta:
+        model = Document
+        fields = ["rfc_number", "stream"]
+
+
+class ReferenceSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Document
+        fields = ["id", "name"]
+        read_only_fields = ["id", "name"]

ietf/api/tests_views_rpc.py

@@ -0,0 +1,69 @@
+# Copyright The IETF Trust 2025, All Rights Reserved
+# -*- coding: utf-8 -*-
+
+from django.test.utils import override_settings
+from django.urls import reverse as urlreverse
+
+from ietf.doc.factories import IndividualDraftFactory
+from ietf.doc.models import RelatedDocument
+from ietf.utils.test_utils import TestCase, reload_db_objects
+
+
+class RpcApiTests(TestCase):
+    @override_settings(APP_API_TOKENS={"ietf.api.views_rpc": ["valid-token"]})
+    def test_api_refs(self):
+        # non-existent draft
+        url = urlreverse("ietf.api.views_rpc.rpc_draft_refs", kwargs={"doc_id": 999999})
+        r = self.client.get(url)
+        self.assertEqual(r.status_code, 200)
+        r = self.client.get(url, headers={"X-Api-Key": "valid-token"})
+        jsondata = r.json()
+        refs = jsondata["references"]
+        self.assertEqual(refs, [])
+
+        # draft without any normative references
+        draft = IndividualDraftFactory()
+        draft = reload_db_objects(draft)
+        url = urlreverse(
+            "ietf.api.views_rpc.rpc_draft_refs", kwargs={"doc_id": draft.id}
+        )
+        r = self.client.get(url)
+        self.assertEqual(r.status_code, 200)
+        r = self.client.get(url, headers={"X-Api-Key": "valid-token"})
+        jsondata = r.json()
+        refs = jsondata["references"]
+        self.assertEqual(refs, [])
+
+        # draft without any normative references but with an informative reference
+        draft_foo = IndividualDraftFactory()
+        draft_foo = reload_db_objects(draft_foo)
+        RelatedDocument.objects.create(
+            source=draft, target=draft_foo, relationship_id="refinfo"
+        )
+        url = urlreverse(
+            "ietf.api.views_rpc.rpc_draft_refs", kwargs={"doc_id": draft.id}
+        )
+        r = self.client.get(url)
+        self.assertEqual(r.status_code, 200)
+        r = self.client.get(url, headers={"X-Api-Key": "valid-token"})
+        jsondata = r.json()
+        refs = jsondata["references"]
+        self.assertEqual(refs, [])
+
+        # draft with a normative reference
+        draft_bar = IndividualDraftFactory()
+        draft_bar = reload_db_objects(draft_bar)
+        RelatedDocument.objects.create(
+            source=draft, target=draft_bar, relationship_id="refnorm"
+        )
+        url = urlreverse(
+            "ietf.api.views_rpc.rpc_draft_refs", kwargs={"doc_id": draft.id}
+        )
+        r = self.client.get(url)
+        self.assertEqual(r.status_code, 200)
+        r = self.client.get(url, headers={"X-Api-Key": "valid-token"})
+        jsondata = r.json()
+        refs = jsondata["references"]
+        self.assertEqual(len(refs), 1)
+        self.assertEqual(refs[0]["id"], draft_bar.id)
+        self.assertEqual(refs[0]["name"], draft_bar.name)

ietf/api/urls.py

@@ -1,26 +1,31 @@
 # Copyright The IETF Trust 2017-2024, All Rights Reserved
 
+from drf_spectacular.views import SpectacularAPIView
+
 from django.conf import settings
-from django.urls import include
+from django.urls import include, path
 from django.views.generic import TemplateView
 
 from ietf import api
-from ietf.doc import views_ballot
+from ietf.doc import views_ballot, api as doc_api
 from ietf.meeting import views as meeting_views
 from ietf.submit import views as submit_views
 from ietf.utils.urls import url
 
 from . import views as api_views
+from .routers import PrefixedSimpleRouter 
 
 # DRF API routing - disabled until we plan to use it
-# from drf_spectacular.views import SpectacularAPIView
-# from django.urls import path
 # from ietf.person import api as person_api
-# from .routers import PrefixedSimpleRouter 
 # core_router = PrefixedSimpleRouter(name_prefix="ietf.api.core_api")  # core api router
 # core_router.register("email", person_api.EmailViewSet)
 # core_router.register("person", person_api.PersonViewSet)
 
+# todo more general name for this API?
+red_router = PrefixedSimpleRouter(name_prefix="ietf.api.red_api")  # red api router
+red_router.register("doc", doc_api.RfcViewSet)
+red_router.register("subseries", doc_api.SubseriesViewSet, basename="subseries")
+
 api.autodiscover()
 
 urlpatterns = [
@@ -32,7 +37,9 @@
     url(r'^v2/person/person', api_views.ApiV2PersonExportView.as_view()),
     # --- DRF API ---
     # path("core/", include(core_router.urls)),
-    # path("schema/", SpectacularAPIView.as_view()),
+    path("purple/", include("ietf.api.urls_rpc")),
+    path("red/", include(red_router.urls)),
+    path("schema/", SpectacularAPIView.as_view()),
     #
     # --- Custom API endpoints, sorted alphabetically ---
     # Email alias information for drafts

ietf/api/urls_rpc.py

@@ -0,0 +1,33 @@
+# Copyright The IETF Trust 2023-2025, All Rights Reserved
+
+from rest_framework import routers
+
+from django.conf import settings
+from django.urls import include, path
+
+from ietf.api import views_rpc, views_rpc_demo
+from ietf.utils.urls import url
+
+router = routers.DefaultRouter()
+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")
+
+if settings.SERVER_MODE not in {"production", "test"}:
+    # for non production demos
+    router.register(r"demo", views_rpc_demo.DemoViewSet, basename="demo")
+
+
+urlpatterns = [
+    url(r"^doc/drafts_by_names/", views_rpc.DraftsByNamesView.as_view()),
+    url(r"^persons/search/", views_rpc.RpcPersonSearch.as_view()),
+    path(r"subject/<str:subject_id>/person/", views_rpc.SubjectPersonView.as_view()),
+]
+
+# add routers at the end so individual routes can steal parts of their address
+# space (specifically, ^person/ routes so far)
+urlpatterns.extend(
+    [
+        path("", include(router.urls)),
+    ]
+)