Scope participant cache by conference

Author: patrick91

backend/api/conferences/types.py

@@ -102,16 +102,30 @@ def speakers(self, info: Info) -> list[ScheduleItemUser]:
         keynote_speakers = [
             speaker for speaker in self.speakers.all() if speaker.user_id
         ]
-        participants_data = info.context._participants_data
-        if participants_data is None:
-            participants_data = {
-                participant.user_id: participant
-                for participant in participant_models.Participant.objects.filter(
-                    user_id__in=[speaker.user_id for speaker in keynote_speakers],
-                    conference_id=self.conference_id,
-                ).all()
-            }
-            info.context._participants_data = participants_data
+        participants_by_conference = info.context._participants_data
+        if participants_by_conference is None:
+            participants_by_conference = {}
+            info.context._participants_data = participants_by_conference
+
+        participants_data = participants_by_conference.setdefault(
+            self.conference_id, {}
+        )
+        missing_user_ids = [
+            speaker.user_id
+            for speaker in keynote_speakers
+            if speaker.user_id not in participants_data
+        ]
+        if missing_user_ids:
+            participants_data.update({user_id: None for user_id in missing_user_ids})
+            participants_data.update(
+                {
+                    participant.user_id: participant
+                    for participant in participant_models.Participant.objects.filter(
+                        user_id__in=missing_user_ids,
+                        conference_id=self.conference_id,
+                    ).all()
+                }
+            )
 
         return [
             ScheduleItemUser(

backend/api/context.py

@@ -1,19 +1,20 @@
 from dataclasses import dataclass
-from typing import Any, Dict, Optional, TypeAlias
+from typing import Any
 
 from django.http.request import HttpRequest
 from strawberry.types import Info as StrawberryInfo
 
+from participants.models import Participant
 from voting.models.vote import Vote
 
 
 @dataclass
 class Context:
     request: HttpRequest
     response: Any
-    _user_can_vote: Optional[bool] = None
-    _participants_data: Optional[Any] = None
-    _my_votes: Optional[Dict[int, Vote]] = None
+    _user_can_vote: bool | None = None
+    _participants_data: dict[int, dict[int, Participant | None]] | None = None
+    _my_votes: dict[int, Vote] | None = None
 
 
-Info: TypeAlias = StrawberryInfo[Context, Any]
+type Info = StrawberryInfo[Context, Any]

backend/api/schedule/queries/search_events_for_schedule.py

@@ -13,7 +13,7 @@
 
 @strawberry.type
 class SearchEventsForScheduleResult:
-    conference_id: strawberry.Private[strawberry.ID]
+    conference_id: strawberry.Private[int]
     proposals: strawberry.Private[QuerySet[SubmissionModel]]
     keynotes: strawberry.Private[QuerySet[KeynoteModel]]
 
@@ -27,11 +27,17 @@ def results(self, info: Info) -> list[Submission | Keynote]:
             Q(user_id__in=self.proposals.values("speaker_id"))
             | Q(user_id__in=self.keynotes.values("speakers__user_id"))
         )
-        participants_data = info.context._participants_data or {}
+        participants_by_conference = info.context._participants_data
+        if participants_by_conference is None:
+            participants_by_conference = {}
+            info.context._participants_data = participants_by_conference
+
+        participants_data = participants_by_conference.setdefault(
+            self.conference_id, {}
+        )
         participants_data.update(
             {participant.user_id: participant for participant in participants}
         )
-        info.context._participants_data = participants_data
 
         # The mixed union has to become a list here, so optimize each queryset
         # before Strawberry loses the opportunity to inspect its model type.
@@ -71,7 +77,7 @@ def search_events_for_schedule(
     )
 
     return SearchEventsForScheduleResult(
-        conference_id=conference_id,
+        conference_id=int(conference_id),
         proposals=proposals,
         keynotes=keynotes,
     )

backend/api/schedule/tests/test_search_events_for_schedule.py

@@ -1,6 +1,7 @@
 import pytest
 
 from conferences.tests.factories import (
+    ConferenceFactory,
     DurationFactory,
     KeynoteFactory,
     KeynoteSpeakerFactory,
@@ -60,6 +61,40 @@
 """
 
 
+MULTI_CONFERENCE_SEARCH_EVENTS_QUERY = """
+query SearchEvents($firstConferenceId: ID!, $secondConferenceId: ID!) {
+  first: searchEventsForSchedule(
+    conferenceId: $firstConferenceId
+    query: "Shared"
+  ) {
+    results {
+      ... on Submission {
+        speaker {
+          participant {
+            speakerAvailabilities
+          }
+        }
+      }
+    }
+  }
+  second: searchEventsForSchedule(
+    conferenceId: $secondConferenceId
+    query: "Shared"
+  ) {
+    results {
+      ... on Submission {
+        speaker {
+          participant {
+            speakerAvailabilities
+          }
+        }
+      }
+    }
+  }
+}
+"""
+
+
 def _search_events_for_schedule(client, **input):
     return client.query(
         """query SearchEventsForSchedule($conferenceId: ID!, $query: String!) {
@@ -151,7 +186,7 @@ def test_frontend_search_events_query(
         )
 
     assert "errors" not in response
-    assert response["data"] == {
+    expected_data = {
         "searchEvents": {
             "results": [
                 *[
@@ -202,6 +237,63 @@ def test_frontend_search_events_query(
             ]
         }
     }
+    response["data"]["searchEvents"]["results"].sort(key=lambda result: result["id"])
+    expected_data["searchEvents"]["results"].sort(key=lambda result: result["id"])
+    assert response["data"] == expected_data
+
+
+def test_frontend_search_events_query_keeps_participants_scoped_by_conference(
+    admin_graphql_api_client,
+    admin_superuser,
+    django_assert_num_queries,
+):
+    conferences = [ConferenceFactory(), ConferenceFactory()]
+    speaker = UserFactory(full_name="Shared Speaker")
+
+    for index, conference in enumerate(conferences, start=1):
+        ParticipantFactory(
+            conference=conference,
+            user=speaker,
+            speaker_availabilities={"conference": index},
+        )
+        SubmissionFactory(
+            conference=conference,
+            speaker=speaker,
+            status=Submission.STATUS.accepted,
+            title=LazyI18nString({"en": f"Shared Talk {index}", "it": ""}),
+        )
+
+    admin_graphql_api_client.force_login(admin_superuser)
+    with django_assert_num_queries(10):
+        response = admin_graphql_api_client.query(
+            MULTI_CONFERENCE_SEARCH_EVENTS_QUERY,
+            variables={
+                "firstConferenceId": str(conferences[0].id),
+                "secondConferenceId": str(conferences[1].id),
+            },
+        )
+
+    assert "errors" not in response
+    assert response["data"] == {
+        "first": {
+            "results": [
+                {
+                    "speaker": {
+                        "participant": {"speakerAvailabilities": {"conference": 1}}
+                    }
+                }
+            ]
+        },
+        "second": {
+            "results": [
+                {
+                    "speaker": {
+                        "participant": {"speakerAvailabilities": {"conference": 2}}
+                    }
+                }
+            ]
+        },
+    }
 
 
 @pytest.mark.parametrize("user_to_test", ["admin_user", "user", "not_authenticated"])

backend/api/schedule/types/schedule_item.py

@@ -173,30 +173,6 @@ def user_is_talk_manager(self, info: Info) -> bool:
         ],
     )
     def speakers(self, info: Info) -> list[ScheduleItemUser]:
-        speakers = []
-
-        participants_data = info.context._participants_data
-        if participants_data is None:
-            schedule_items = models.ScheduleItem.objects.filter(
-                conference_id=self.conference_id
-            )
-            submission_speakers = schedule_items.values("submission__speaker_id")
-            keynote_speakers = schedule_items.values("keynote__speakers__user_id")
-            additional_speakers = schedule_items.values("additional_speakers__user_id")
-            participants_data = {
-                participant.user_id: participant
-                for participant in participant_models.Participant.objects.filter(
-                    conference_id=self.conference_id
-                )
-                .filter(
-                    django_models.Q(user_id__in=submission_speakers)
-                    | django_models.Q(user_id__in=keynote_speakers)
-                    | django_models.Q(user_id__in=additional_speakers)
-                )
-                .select_related("user")
-            }
-            info.context._participants_data = participants_data
-
         schedule_item_speakers = []
         if self.submission_id:
             schedule_item_speakers.append(self.submission.speaker)
@@ -209,7 +185,42 @@ def speakers(self, info: Info) -> list[ScheduleItemUser]:
         schedule_item_speakers.extend(
             speaker.user for speaker in self.additional_speakers.all()
         )
+        speaker_ids = {
+            speaker.id for speaker in schedule_item_speakers if speaker is not None
+        }
 
+        participants_by_conference = info.context._participants_data
+        if participants_by_conference is None:
+            participants_by_conference = {}
+            info.context._participants_data = participants_by_conference
+
+        participants_data = participants_by_conference.setdefault(
+            self.conference_id, {}
+        )
+        if not speaker_ids.issubset(participants_data):
+            participants_data.update({speaker_id: None for speaker_id in speaker_ids})
+            schedule_items = models.ScheduleItem.objects.filter(
+                conference_id=self.conference_id
+            )
+            submission_speakers = schedule_items.values("submission__speaker_id")
+            keynote_speakers = schedule_items.values("keynote__speakers__user_id")
+            additional_speakers = schedule_items.values("additional_speakers__user_id")
+            participants_data.update(
+                {
+                    participant.user_id: participant
+                    for participant in participant_models.Participant.objects.filter(
+                        conference_id=self.conference_id
+                    )
+                    .filter(
+                        django_models.Q(user_id__in=submission_speakers)
+                        | django_models.Q(user_id__in=keynote_speakers)
+                        | django_models.Q(user_id__in=additional_speakers)
+                    )
+                    .select_related("user")
+                }
+            )
+
+        speakers = []
         for speaker in schedule_item_speakers:
             if speaker is None:
                 continue

backend/api/submissions/types.py

@@ -52,15 +52,19 @@ class SubmissionSpeaker:
     id: strawberry.ID
     full_name: str
     gender: str
-    _conference_id: strawberry.Private[str]
+    _conference_id: strawberry.Private[int]
 
     @strawberry_django.field
     def participant(
         self,
         info: Info,
     ) -> Annotated["Participant", strawberry.lazy("api.participants.types")] | None:
-        if info.context._participants_data is not None:
-            return info.context._participants_data.get(self.id)
+        participants_by_conference = info.context._participants_data
+        if participants_by_conference is not None:
+            participants_data = participants_by_conference.get(self._conference_id)
+            user_id = int(self.id)
+            if participants_data is not None and user_id in participants_data:
+                return participants_data[user_id]
 
         return participant_models.Participant.objects.for_conference(
             self._conference_id