fix: update RPC publish API fields (ietf-tools#10308)

* fix: update purple publish API fields

* fix: handle IntegrityError more cleanly

* fix: don't import RFC fields from draft

* test: update test

* chore: remove unused var/import

* fix: f-string -> string

Author: jennifer-richards

ietf/api/serializers_rpc.py

@@ -27,7 +27,7 @@
     update_rfcauthors,
 )
 from ietf.group.models import Group
-from ietf.name.models import StreamName, StdLevelName, FormalLanguageName
+from ietf.name.models import StreamName, StdLevelName
 from ietf.person.models import Person
 from ietf.utils import log
 
@@ -137,7 +137,6 @@ class Meta:
             "pages",
             "source_format",
             "authors",
-            "shepherd",
             "intended_std_level",
             "consensus",
             "shepherd",
@@ -263,15 +262,6 @@ class RfcPubSerializer(serializers.ModelSerializer):
     stream = serializers.PrimaryKeyRelatedField(
         queryset=StreamName.objects.filter(used=True)
     )
-    formal_languages = serializers.PrimaryKeyRelatedField(
-        many=True,
-        required=False,
-        queryset=FormalLanguageName.objects.filter(used=True),
-        help_text=(
-            "formal languages used in RFC (defaults to those from draft, send empty"
-            "list to override)"
-        )
-    )
     std_level = serializers.PrimaryKeyRelatedField(
         queryset=StdLevelName.objects.filter(used=True),
     )
@@ -315,11 +305,8 @@ class Meta:
             "stream",
             "abstract",
             "pages",
-            "words",
-            "formal_languages",
             "std_level",
             "ad",
-            "note",
             "obsoletes",
             "updates",
             "subseries",
@@ -353,9 +340,6 @@ def create(self, validated_data):
         # If specified, retrieve draft and extract RFC default values from it
         if draft_name is None:
             draft = None
-            defaults_from_draft = {
-                "group": Group.objects.get(acronym="none", type_id="individ"),
-            }
         else:
             # validation enforces that draft_name and draft_rev are both present
             draft = Document.objects.filter(
@@ -378,17 +362,11 @@ def create(self, validated_data):
                     },
                     code="already-published-draft",
                 )
-            defaults_from_draft = {
-                "ad": draft.ad,
-                "formal_languages": draft.formal_languages.all(),
-                "group": draft.group,
-                "note": draft.note,
-            }
 
         # Transaction to clean up if something fails
         with transaction.atomic():
             # create rfc, letting validated request data override draft defaults
-            rfc = self._create_rfc(defaults_from_draft | validated_data)
+            rfc = self._create_rfc(validated_data)
             DocEvent.objects.create(
                 doc=rfc,
                 rev=rfc.rev,
@@ -523,14 +501,11 @@ def create(self, validated_data):
 
     def _create_rfc(self, validated_data):
         authors_data = validated_data.pop("authors")
-        formal_languages = validated_data.pop("formal_languages", [])
-        # todo ad field
         rfc = Document.objects.create(
             type_id="rfc",
             name=f"rfc{validated_data['rfc_number']}",
             **validated_data,
         )
-        rfc.formal_languages.set(formal_languages)  # list of PKs is ok
         for order, author_data in enumerate(authors_data):
             rfc.rfcauthor_set.create(
                 order=order,

ietf/api/tests_views_rpc.py

@@ -80,9 +80,15 @@ def test_draftviewset_references(self):
     def test_notify_rfc_published(self):
         url = urlreverse("ietf.api.purple_api.notify_rfc_published")
         area = GroupFactory(type_id="area")
+        rfc_group = GroupFactory(type_id="wg")
         draft_ad = RoleFactory(group=area, name_id="ad").person
-        authors = PersonFactory.create_batch(2)
-        draft = WgDraftFactory(group__parent=area, authors=authors)
+        rfc_ad = PersonFactory()
+        draft_authors = PersonFactory.create_batch(2)
+        rfc_authors = PersonFactory.create_batch(3)
+        draft = WgDraftFactory(
+            group__parent=area, authors=draft_authors, ad=draft_ad, stream_id="ietf"
+        )
+        rfc_stream_id = "ise"
         assert isinstance(draft, Document), "WgDraftFactory should generate a Document"
         unused_rfc_number = (
             Document.objects.filter(rfc_number__isnull=False).aggregate(
@@ -96,7 +102,7 @@ def test_notify_rfc_published(self):
             "draft_name": draft.name,
             "draft_rev": draft.rev,
             "rfc_number": unused_rfc_number,
-            "title": draft.title,
+            "title": "RFC " + draft.title,
             "authors": [
                 {
                     "titlepage_name": f"titlepage {author.name}",
@@ -106,17 +112,14 @@ def test_notify_rfc_published(self):
                     "affiliation": "Some Affiliation",
                     "country": "CA",
                 }
-                for author in authors
+                for author in rfc_authors
             ],
-            "group": draft.group.acronym,
-            "stream": draft.stream_id,
-            "abstract": draft.abstract,
-            "pages": draft.pages,
-            "words": draft.pages * 250,
-            "formal_languages": [],
+            "group": rfc_group.acronym,
+            "stream": rfc_stream_id,
+            "abstract": "RFC version of " + draft.abstract,
+            "pages": draft.pages + 10,
             "std_level": "ps",
-            "ad": draft_ad.pk,
-            "note": "noted",
+            "ad": rfc_ad.pk,
             "obsoletes": [],
             "updates": [],
             "subseries": [],
@@ -137,7 +140,7 @@ def test_notify_rfc_published(self):
             ).count(),
             1,
         )
-        self.assertEqual(rfc.title, draft.title)
+        self.assertEqual(rfc.title, "RFC " + draft.title)
         self.assertEqual(rfc.documentauthor_set.count(), 0)
         self.assertEqual(
             list(
@@ -159,18 +162,15 @@ def test_notify_rfc_published(self):
                     "affiliation": "Some Affiliation",
                     "country": "CA",
                 }
-                for author in authors
+                for author in rfc_authors
             ],
         )
-        self.assertEqual(rfc.group, draft.group)
-        self.assertEqual(rfc.stream, draft.stream)
-        self.assertEqual(rfc.abstract, draft.abstract)
-        self.assertEqual(rfc.pages, draft.pages)
-        self.assertEqual(rfc.words, draft.pages * 250)
-        self.assertEqual(rfc.formal_languages.count(), 0)
+        self.assertEqual(rfc.group, rfc_group)
+        self.assertEqual(rfc.stream_id, rfc_stream_id)
+        self.assertEqual(rfc.abstract, "RFC version of " + draft.abstract)
+        self.assertEqual(rfc.pages, draft.pages + 10)
         self.assertEqual(rfc.std_level_id, "ps")
-        self.assertEqual(rfc.ad, draft_ad)
-        self.assertEqual(rfc.note, "noted")
+        self.assertEqual(rfc.ad, rfc_ad)
         self.assertEqual(rfc.related_that_doc("obs"), [])
         self.assertEqual(rfc.related_that_doc("updates"), [])
         self.assertEqual(rfc.part_of(), [])

ietf/api/views_rpc.py

@@ -5,6 +5,7 @@
 from tempfile import TemporaryDirectory
 
 from django.conf import settings
+from django.db import IntegrityError
 from drf_spectacular.utils import OpenApiParameter
 from rest_framework import mixins, parsers, serializers, viewsets, status
 from rest_framework.decorators import action
@@ -360,7 +361,20 @@ def post(self, request):
         serializer = RfcPubSerializer(data=request.data)
         serializer.is_valid(raise_exception=True)
         # Create RFC
-        serializer.save()
+        try:
+            serializer.save()
+        except IntegrityError as err:
+            if Document.objects.filter(
+                rfc_number=serializer.validated_data["rfc_number"]
+            ):
+                raise serializers.ValidationError(
+                    "RFC with that number already exists",
+                    code="rfc-number-in-use",
+                )
+            raise serializers.ValidationError(
+                f"Unable to publish: {err}",
+                code="unknown-integrity-error",
+            )
         return Response(NotificationAckSerializer().data)