refactor: Tie Meetecho resources to Session pk (ietf-tools#5281)

* feat: Use session.id to specify session for api_set_session_video_url

* feat: Use session.id to specify session for api_upload_bluesheet

* refactor: Add audio/video stream and onsite tool URLs to Session model

* refactor: Get onsite tool/stream URLs for agenda from Session

* refactor: Use Session methods for onsite tool/stream a few more places

* refactor: Move hard-coded meetecho URLs into settings.py

* feat: Add has_onsite_flag to Session

* chore: Set has_onsite_tool for sessions that had meetecho UrlResources

* fix: Only show onsite tool URLs when Session.has_onsite_tool is True

* test: Update test_api_upload_bluesheet to test deprecated version

* fix: Fix test failure in api_upload_bluesheet view

* test: Add test of new api_upload_bluesheet view

* style: Apply Black style to test_api_upload_bluesheet

* fix: Fix test failures in api_upload_bluesheet()

* test: Update test_api_set_session_video_url to test deprecated version

* fix: Fix test failure in api_set_session_video_url view

* test: Add test of new api_set_session_video_url view

* style: Apply Black styling to new test

* fix: Fix test failures in api_set_session_video_url view

* test: Fix test_meeting_agenda; set has_onsite_tool in SessionFactory

* feat: Add has_onsite_tool to Session list in admin

* feat: Add has_onsite_tool flag to SessionDetailsForm

* feat: Add has_onsite_tool flag to sreq

* feat: Show has_onsite_tool flag on secr view for a submitted request

* feat: Only prompt for has_onsite_tool in sreq for non-wg type groups

* fix: Clean up styling of sreq view a bit

* chore: Renumber migrations

Author: jennifer-richards

ietf/api/tests.py

@@ -55,7 +55,7 @@ def test_api_openid_issuer(self):
         r = self.client.get(url)
         self.assertContains(r, 'OpenID Connect Issuer', status_code=200)
 
-    def test_api_set_session_video_url(self):
+    def test_deprecated_api_set_session_video_url(self):
         url = urlreverse('ietf.meeting.views.api_set_session_video_url')
         recmanrole = RoleFactory(group__type_id='ietf', name_id='recman')
         recman = recmanrole.person
@@ -84,7 +84,7 @@ def test_api_set_session_video_url(self):
         r = self.client.get(url, {'apikey': apikey.hash()} )
         self.assertContains(r, "Method not allowed", status_code=405)
 
-        r = self.client.post(url, {'apikey': apikey.hash()} )
+        r = self.client.post(url, {'apikey': apikey.hash(), 'group': group.acronym} )
         self.assertContains(r, "Missing meeting parameter", status_code=400)
 
 
@@ -136,6 +136,83 @@ def test_api_set_session_video_url(self):
         event = doc.latest_event()
         self.assertEqual(event.by, recman)
 
+    def test_api_set_session_video_url(self):
+        url = urlreverse("ietf.meeting.views.api_set_session_video_url")
+        recmanrole = RoleFactory(group__type_id="ietf", name_id="recman")
+        recman = recmanrole.person
+        meeting = MeetingFactory(type_id="ietf")
+        session = SessionFactory(group__type_id="wg", meeting=meeting)
+        apikey = PersonalApiKey.objects.create(endpoint=url, person=recman)
+        video = "https://foo.example.com/bar/beer/"
+
+        # error cases
+        r = self.client.post(url, {})
+        self.assertContains(r, "Missing apikey parameter", status_code=400)
+
+        badrole = RoleFactory(group__type_id="ietf", name_id="ad")
+        badapikey = PersonalApiKey.objects.create(endpoint=url, person=badrole.person)
+        badrole.person.user.last_login = timezone.now()
+        badrole.person.user.save()
+        r = self.client.post(url, {"apikey": badapikey.hash()})
+        self.assertContains(r, "Restricted to role: Recording Manager", status_code=403)
+
+        r = self.client.post(url, {"apikey": apikey.hash()})
+        self.assertContains(r, "Too long since last regular login", status_code=400)
+        recman.user.last_login = timezone.now()
+        recman.user.save()
+
+        r = self.client.get(url, {"apikey": apikey.hash()})
+        self.assertContains(r, "Method not allowed", status_code=405)
+
+        r = self.client.post(url, {"apikey": apikey.hash()})
+        self.assertContains(r, "Missing session_id parameter", status_code=400)
+
+        r = self.client.post(url, {"apikey": apikey.hash(), "session_id": session.pk})
+        self.assertContains(r, "Missing url parameter", status_code=400)
+
+        bad_pk = int(Session.objects.order_by("-pk").first().pk) + 1
+        r = self.client.post(
+            url,
+            {
+                "apikey": apikey.hash(),
+                "session_id": bad_pk,
+                "url": video,
+            },
+        )
+        self.assertContains(r, "Session not found", status_code=400)
+
+        r = self.client.post(
+            url,
+            {
+                "apikey": apikey.hash(),
+                "session_id": "foo",
+                "url": video,
+            },
+        )
+        self.assertContains(r, "Invalid session_id", status_code=400)
+
+        r = self.client.post(
+            url,
+            {
+                "apikey": apikey.hash(),
+                "session_id": session.pk,
+                "url": "foobar",
+            },
+        )
+        self.assertContains(r, "Invalid url value: 'foobar'", status_code=400)
+
+        r = self.client.post(
+            url, {"apikey": apikey.hash(), "session_id": session.pk, "url": video}
+        )
+        self.assertContains(r, "Done", status_code=200)
+
+        recordings = session.recordings()
+        self.assertEqual(len(recordings), 1)
+        doc = recordings[0]
+        self.assertEqual(doc.external_url, video)
+        event = doc.latest_event()
+        self.assertEqual(event.by, recman)
+
     def test_api_add_session_attendees(self):
         url = urlreverse('ietf.meeting.views.api_add_session_attendees')
         otherperson = PersonFactory()
@@ -289,20 +366,20 @@ def test_api_upload_polls_and_chatlog(self):
             newdoccontent = get_unicode_document_content(newdoc.name, Path(session.meeting.get_materials_path()) / type_id / newdoc.uploaded_filename)
             self.assertEqual(json.loads(content), json.loads(newdoccontent))
 
-    def test_api_upload_bluesheet(self):
+    def test_deprecated_api_upload_bluesheet(self):
         url = urlreverse('ietf.meeting.views.api_upload_bluesheet')
         recmanrole = RoleFactory(group__type_id='ietf', name_id='recman')
         recman = recmanrole.person
         meeting = MeetingFactory(type_id='ietf')
         session = SessionFactory(group__type_id='wg', meeting=meeting)
         group = session.group
         apikey = PersonalApiKey.objects.create(endpoint=url, person=recman)
-        
+
         people = [
-                {"name":"Andrea Andreotti", "affiliation": "Azienda"},
-                {"name":"Bosse Bernadotte", "affiliation": "Bolag"},
-                {"name":"Charles Charlemagne", "affiliation": "Compagnie"},
-            ]
+            {"name": "Andrea Andreotti", "affiliation": "Azienda"},
+            {"name": "Bosse Bernadotte", "affiliation": "Bolag"},
+            {"name": "Charles Charlemagne", "affiliation": "Compagnie"},
+        ]
         for i in range(3):
             faker = random_faker()
             people.append(dict(name=faker.name(), affiliation=faker.company()))
@@ -312,63 +389,63 @@ def test_api_upload_bluesheet(self):
         r = self.client.post(url, {})
         self.assertContains(r, "Missing apikey parameter", status_code=400)
 
-        badrole  = RoleFactory(group__type_id='ietf', name_id='ad')
+        badrole = RoleFactory(group__type_id='ietf', name_id='ad')
         badapikey = PersonalApiKey.objects.create(endpoint=url, person=badrole.person)
         badrole.person.user.last_login = timezone.now()
         badrole.person.user.save()
-        r = self.client.post(url, {'apikey': badapikey.hash()} )
+        r = self.client.post(url, {'apikey': badapikey.hash()})
         self.assertContains(r, "Restricted to roles: Recording Manager, Secretariat", status_code=403)
 
-        r = self.client.post(url, {'apikey': apikey.hash()} )
+        r = self.client.post(url, {'apikey': apikey.hash()})
         self.assertContains(r, "Too long since last regular login", status_code=400)
         recman.user.last_login = timezone.now()
         recman.user.save()
 
-        r = self.client.get(url, {'apikey': apikey.hash()} )
+        r = self.client.get(url, {'apikey': apikey.hash()})
         self.assertContains(r, "Method not allowed", status_code=405)
 
-        r = self.client.post(url, {'apikey': apikey.hash()} )
+        r = self.client.post(url, {'apikey': apikey.hash(), 'group': group.acronym})
         self.assertContains(r, "Missing meeting parameter", status_code=400)
 
-
-        r = self.client.post(url, {'apikey': apikey.hash(), 'meeting': meeting.number, } )
+        r = self.client.post(url, {'apikey': apikey.hash(), 'meeting': meeting.number, })
         self.assertContains(r, "Missing group parameter", status_code=400)
 
-        r = self.client.post(url, {'apikey': apikey.hash(), 'meeting': meeting.number, 'group': group.acronym} )
+        r = self.client.post(url, {'apikey': apikey.hash(), 'meeting': meeting.number, 'group': group.acronym})
         self.assertContains(r, "Missing item parameter", status_code=400)
 
-        r = self.client.post(url, {'apikey': apikey.hash(), 'meeting': meeting.number, 'group': group.acronym, 'item': '1'} )
+        r = self.client.post(url,
+                             {'apikey': apikey.hash(), 'meeting': meeting.number, 'group': group.acronym, 'item': '1'})
         self.assertContains(r, "Missing bluesheet parameter", status_code=400)
 
         r = self.client.post(url, {'apikey': apikey.hash(), 'meeting': '1', 'group': group.acronym,
-                                    'item': '1', 'bluesheet': bluesheet, })
+                                   'item': '1', 'bluesheet': bluesheet, })
         self.assertContains(r, "No sessions found for meeting", status_code=400)
 
         r = self.client.post(url, {'apikey': apikey.hash(), 'meeting': meeting.number, 'group': 'bogous',
-                                    'item': '1', 'bluesheet': bluesheet, })
-        self.assertContains(r, "No sessions found in meeting '%s' for group 'bogous'"%meeting.number, status_code=400)
+                                   'item': '1', 'bluesheet': bluesheet, })
+        self.assertContains(r, "No sessions found in meeting '%s' for group 'bogous'" % meeting.number, status_code=400)
 
         r = self.client.post(url, {'apikey': apikey.hash(), 'meeting': meeting.number, 'group': group.acronym,
-                                    'item': '1', 'bluesheet': "foobar", })
+                                   'item': '1', 'bluesheet': "foobar", })
         self.assertContains(r, "Invalid json value: 'foobar'", status_code=400)
 
         r = self.client.post(url, {'apikey': apikey.hash(), 'meeting': meeting.number, 'group': group.acronym,
-                                    'item': '5', 'bluesheet': bluesheet, })
+                                   'item': '5', 'bluesheet': bluesheet, })
         self.assertContains(r, "No item '5' found in list of sessions for group", status_code=400)
 
         r = self.client.post(url, {'apikey': apikey.hash(), 'meeting': meeting.number, 'group': group.acronym,
-                                    'item': 'foo', 'bluesheet': bluesheet, })
+                                   'item': 'foo', 'bluesheet': bluesheet, })
         self.assertContains(r, "Expected a numeric value for 'item', found 'foo'", status_code=400)
 
         r = self.client.post(url, {'apikey': apikey.hash(), 'meeting': meeting.number, 'group': group.acronym,
-                                    'item': '1', 'bluesheet': bluesheet, })
+                                   'item': '1', 'bluesheet': bluesheet, })
         self.assertContains(r, "Done", status_code=200)
 
         # Submit again, with slightly different content, as an updated version
         people[1]['affiliation'] = 'Bolaget AB'
         bluesheet = json.dumps(people)
         r = self.client.post(url, {'apikey': apikey.hash(), 'meeting': meeting.number, 'group': group.acronym,
-                                    'item': '1', 'bluesheet': bluesheet, })
+                                   'item': '1', 'bluesheet': bluesheet, })
         self.assertContains(r, "Done", status_code=200)
 
         bluesheet = session.sessionpresentation_set.filter(document__type__slug='bluesheets').first().document
@@ -381,6 +458,124 @@ def test_api_upload_bluesheet(self):
                 self.assertIn(p['name'], html.unescape(text))
                 self.assertIn(p['affiliation'], html.unescape(text))
 
+    def test_api_upload_bluesheet(self):
+        url = urlreverse("ietf.meeting.views.api_upload_bluesheet")
+        recmanrole = RoleFactory(group__type_id="ietf", name_id="recman")
+        recman = recmanrole.person
+        meeting = MeetingFactory(type_id="ietf")
+        session = SessionFactory(group__type_id="wg", meeting=meeting)
+        group = session.group
+        apikey = PersonalApiKey.objects.create(endpoint=url, person=recman)
+
+        people = [
+            {"name": "Andrea Andreotti", "affiliation": "Azienda"},
+            {"name": "Bosse Bernadotte", "affiliation": "Bolag"},
+            {"name": "Charles Charlemagne", "affiliation": "Compagnie"},
+        ]
+        for i in range(3):
+            faker = random_faker()
+            people.append(dict(name=faker.name(), affiliation=faker.company()))
+        bluesheet = json.dumps(people)
+
+        # error cases
+        r = self.client.post(url, {})
+        self.assertContains(r, "Missing apikey parameter", status_code=400)
+
+        badrole = RoleFactory(group__type_id="ietf", name_id="ad")
+        badapikey = PersonalApiKey.objects.create(endpoint=url, person=badrole.person)
+        badrole.person.user.last_login = timezone.now()
+        badrole.person.user.save()
+        r = self.client.post(url, {"apikey": badapikey.hash()})
+        self.assertContains(
+            r, "Restricted to roles: Recording Manager, Secretariat", status_code=403
+        )
+
+        r = self.client.post(url, {"apikey": apikey.hash()})
+        self.assertContains(r, "Too long since last regular login", status_code=400)
+        recman.user.last_login = timezone.now()
+        recman.user.save()
+
+        r = self.client.get(url, {"apikey": apikey.hash()})
+        self.assertContains(r, "Method not allowed", status_code=405)
+
+        r = self.client.post(url, {"apikey": apikey.hash()})
+        self.assertContains(r, "Missing session_id parameter", status_code=400)
+
+        r = self.client.post(url, {"apikey": apikey.hash(), "session_id": session.pk})
+        self.assertContains(r, "Missing bluesheet parameter", status_code=400)
+
+        r = self.client.post(
+            url,
+            {
+                "apikey": apikey.hash(),
+                "meeting": meeting.number,
+                "group": group.acronym,
+                "item": "1",
+                "bluesheet": "foobar",
+            },
+        )
+        self.assertContains(r, "Invalid json value: 'foobar'", status_code=400)
+
+        bad_session_pk = int(Session.objects.order_by("-pk").first().pk) + 1
+        r = self.client.post(
+            url,
+            {
+                "apikey": apikey.hash(),
+                "session_id": bad_session_pk,
+                "bluesheet": bluesheet,
+            },
+        )
+        self.assertContains(r, "Session not found", status_code=400)
+
+        r = self.client.post(
+            url,
+            {
+                "apikey": apikey.hash(),
+                "session_id": "foo",
+                "bluesheet": bluesheet,
+            },
+        )
+        self.assertContains(r, "Invalid session_id", status_code=400)
+
+        r = self.client.post(
+            url,
+            {
+                "apikey": apikey.hash(),
+                "session_id": session.pk,
+                "bluesheet": bluesheet,
+            },
+        )
+        self.assertContains(r, "Done", status_code=200)
+
+        # Submit again, with slightly different content, as an updated version
+        people[1]["affiliation"] = "Bolaget AB"
+        bluesheet = json.dumps(people)
+        r = self.client.post(
+            url,
+            {
+                "apikey": apikey.hash(),
+                "meeting": meeting.number,
+                "group": group.acronym,
+                "item": "1",
+                "bluesheet": bluesheet,
+            },
+        )
+        self.assertContains(r, "Done", status_code=200)
+
+        bluesheet = (
+            session.sessionpresentation_set.filter(document__type__slug="bluesheets")
+            .first()
+            .document
+        )
+        # We've submitted an update; check that the rev is right
+        self.assertEqual(bluesheet.rev, "01")
+        # Check the content
+        with open(bluesheet.get_file_name()) as file:
+            text = file.read()
+            for p in people:
+                self.assertIn(p["name"], html.unescape(text))
+                self.assertIn(p["affiliation"], html.unescape(text))
+
     def test_person_export(self):
         person = PersonFactory()
         url = urlreverse('ietf.api.views.PersonalInformationExportView')

ietf/meeting/admin.py

@@ -96,7 +96,9 @@ class SchedulingEventInline(admin.TabularInline):
     raw_id_fields = ["by"]
 
 class SessionAdmin(admin.ModelAdmin):
-    list_display = ["meeting", "name", "group_acronym", "purpose", "attendees", "requested", "current_status"]
+    list_display = [
+        "meeting", "name", "group_acronym", "purpose", "attendees", "has_onsite_tool", "requested", "current_status"
+    ]
     list_filter = ["purpose", "meeting", ]
     raw_id_fields = ["meeting", "group", "materials", "joint_with_groups", "tombstone_for"]
     search_fields = ["meeting__number", "name", "group__name", "group__acronym", "purpose__name"]

ietf/meeting/factories.py

@@ -110,6 +110,7 @@ class Meta:
     group = factory.SubFactory(GroupFactory)
     requested_duration = datetime.timedelta(hours=1)
     on_agenda = factory.lazy_attribute(lambda obj: SessionPurposeName.objects.get(pk=obj.purpose_id).on_agenda)
+    has_onsite_tool = factory.lazy_attribute(lambda obj: obj.purpose_id == 'regular')
 
     @factory.post_generation
     def status_id(obj, create, extracted, **kwargs):

ietf/meeting/forms.py

@@ -727,6 +727,7 @@ def __init__(self, group, *args, **kwargs):
                 'purpose',
                 session_purposes[0] if len(session_purposes) > 0 else None,
             )
+            kwargs['initial'].setdefault('has_onsite_tool', group.features.acts_like_wg)
         super().__init__(*args, **kwargs)
 
         self.fields['type'].widget.attrs.update({
@@ -743,8 +744,8 @@ class Meta:
         model = Session
         fields = (
             'purpose', 'name', 'short', 'type', 'requested_duration',
-            'on_agenda', 'agenda_note', 'remote_instructions', 'attendees',
-            'comments',
+            'on_agenda', 'agenda_note', 'has_onsite_tool', 'remote_instructions',
+            'attendees', 'comments',
         )
         labels = {'requested_duration': 'Length'}
 

ietf/meeting/migrations/0002_session_has_onsite_tool.py

@@ -0,0 +1,18 @@
+# Generated by Django 2.2.28 on 2023-03-07 16:54
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('meeting', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='session',
+            name='has_onsite_tool',
+            field=models.BooleanField(default=False, help_text='Does this session use the officially supported onsite and remote tooling?'),
+        ),
+    ]