Use reverse participant relation

Author: patrick91

backend/api/conferences/types.py

@@ -27,7 +27,6 @@
 from cms import models as cms_models
 from conferences import models as conference_models
 from conferences.models import deadline as deadline_models
-from participants import models as participant_models
 from schedule import models as schedule_models
 from submissions import models as submission_models
 from voting import models as voting_models
@@ -96,43 +95,25 @@ class Keynote:
     # cache. A narrower custom Prefetch is only worthwhile if profiling shows it.
     @strawberry_django.field(
         only=["conference_id"],
-        prefetch_related=["speakers__user"],
+        prefetch_related=["speakers__user__participants"],
     )
-    def speakers(self, info: Info) -> list[ScheduleItemUser]:
+    def speakers(self) -> list[ScheduleItemUser]:
         keynote_speakers = [
             speaker for speaker in self.speakers.all() if speaker.user_id
         ]
-        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(
                 id=speaker.user_id,
                 fullname=speaker.user.full_name,
                 full_name=speaker.user.full_name,
-                participant=participants_data[speaker.user_id],
+                participant=next(
+                    (
+                        participant
+                        for participant in speaker.user.participants.all()
+                        if participant.conference_id == self.conference_id
+                    ),
+                    None,
+                ),
             )
             for speaker in keynote_speakers
         ]

backend/api/context.py

@@ -1,10 +1,9 @@
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 from typing import Any
 
 from django.http.request import HttpRequest
 from strawberry.types import Info as StrawberryInfo
 
-from participants import models as participant_models
 from voting.models.vote import Vote
 
 
@@ -13,10 +12,6 @@ class Context:
     request: HttpRequest
     response: Any
     _user_can_vote: bool | None = None
-    _participants_data: (
-        dict[int, dict[int, participant_models.Participant | None]] | None
-    ) = None
-    _schedule_participants_loaded_conferences: set[int] = field(default_factory=set)
     _my_votes: dict[int, Vote] | None = None
 
 

backend/api/schedule/queries/search_events_for_schedule.py

@@ -7,13 +7,11 @@
 from api.permissions import CanEditSchedule
 from api.submissions.types import Submission
 from conferences.models import Keynote as KeynoteModel
-from participants import models as participant_models
 from submissions.models import Submission as SubmissionModel
 
 
 @strawberry.type
 class SearchEventsForScheduleResult:
-    conference_id: strawberry.Private[int]
     proposals: strawberry.Private[QuerySet[SubmissionModel]]
     keynotes: strawberry.Private[QuerySet[KeynoteModel]]
 
@@ -22,53 +20,15 @@ def results(self, info: Info) -> list[Submission | Keynote]:
         # The mixed union has to become a list here, so optimize each queryset
         # before Strawberry loses the opportunity to inspect its model type.
         # Keep title explicit because the frontend selects its resolver twice
-        # under different aliases. Always prefetch keynote speakers so their
-        # IDs can share the participant batch even when a participant is absent.
+        # under different aliases.
         proposals = list(
             optimize(
                 self.proposals,
                 info,
                 store=OptimizerStore.with_hints(only=["title", "speaker_id"]),
             )
         )
-        keynotes = list(
-            optimize(
-                self.keynotes,
-                info,
-                store=OptimizerStore.with_hints(prefetch_related=["speakers"]),
-            )
-        )
-
-        # Participant deliberately has no reverse User relation, so batch the
-        # speakers from both sides of the union into the shared request cache.
-        speaker_ids = {proposal.speaker_id for proposal in proposals}
-        speaker_ids.update(
-            speaker.user_id
-            for keynote in keynotes
-            for speaker in keynote.speakers.all()
-            if speaker.user_id
-        )
-        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_speaker_ids = speaker_ids - participants_data.keys()
-        participants_data.update(
-            {speaker_id: None for speaker_id in missing_speaker_ids}
-        )
-        participants_data.update(
-            {
-                participant.user_id: participant
-                for participant in participant_models.Participant.objects.filter(
-                    conference_id=self.conference_id,
-                    user_id__in=missing_speaker_ids,
-                )
-            }
-        )
+        keynotes = list(optimize(self.keynotes, info))
 
         return [*proposals, *keynotes]
 
@@ -97,7 +57,6 @@ def search_events_for_schedule(
     )
 
     return SearchEventsForScheduleResult(
-        conference_id=int(conference_id),
         proposals=proposals,
         keynotes=keynotes,
     )

backend/api/schedule/tests/test_search_events_for_schedule.py

@@ -1,6 +1,4 @@
 import pytest
-from django.db import connection
-from django.test.utils import CaptureQueriesContext
 
 from conferences.tests.factories import (
     ConferenceFactory,
@@ -9,7 +7,6 @@
     KeynoteSpeakerFactory,
 )
 from i18n.strings import LazyI18nString
-from participants import models as participant_models
 from participants.tests.factories import ParticipantFactory
 from submissions.models import Submission
 from submissions.tests.factories import SubmissionFactory, SubmissionTypeFactory
@@ -68,7 +65,6 @@
 query SearchEvents(
   $firstConferenceId: ID!
   $secondConferenceId: ID!
-  $uncachedSubmissionId: ID!
 ) {
   first: searchEventsForSchedule(
     conferenceId: $firstConferenceId
@@ -84,13 +80,6 @@
       }
     }
   }
-  uncachedSubmission: submission(id: $uncachedSubmissionId) {
-    speaker {
-      participant {
-        speakerAvailabilities
-      }
-    }
-  }
   second: searchEventsForSchedule(
     conferenceId: $secondConferenceId
     query: "Shared"
@@ -109,32 +98,6 @@
 """
 
 
-CACHED_PARTICIPANT_SEARCH_EVENTS_QUERY = """
-query SearchEvents($code: String!, $conferenceId: ID!) {
-  conference(code: $code) {
-    keynotes {
-      speakers {
-        participant {
-          speakerAvailabilities
-        }
-      }
-    }
-  }
-  searchEventsForSchedule(conferenceId: $conferenceId, query: "Cached") {
-    results {
-      ... on Keynote {
-        speakers {
-          participant {
-            speakerAvailabilities
-          }
-        }
-      }
-    }
-  }
-}
-"""
-
-
 def _search_events_for_schedule(client, **input):
     return client.query(
         """query SearchEventsForSchedule($conferenceId: ID!, $query: String!) {
@@ -156,7 +119,7 @@ def _search_events_for_schedule(client, **input):
 
 @pytest.mark.parametrize(
     ("event_count", "expected_queries"),
-    [(1, 9), (4, 9)],
+    [(1, 10), (4, 10)],
 )
 @pytest.mark.parametrize("has_participant", [True, False])
 def test_frontend_search_events_query(
@@ -311,27 +274,13 @@ def test_frontend_search_events_query_keeps_participants_scoped_by_conference(
             title=LazyI18nString({"en": f"Shared Talk {index}", "it": ""}),
         )
 
-    uncached_speaker = UserFactory(full_name="Uncached Speaker")
-    ParticipantFactory(
-        conference=conferences[1],
-        user=uncached_speaker,
-        speaker_availabilities={"uncached": True},
-    )
-    uncached_submission = SubmissionFactory(
-        conference=conferences[1],
-        speaker=uncached_speaker,
-        status=Submission.STATUS.accepted,
-        title=LazyI18nString({"en": "Unmatched Talk", "it": ""}),
-    )
-
     admin_graphql_api_client.force_login(admin_superuser)
-    with django_assert_num_queries(13):
+    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),
-                "uncachedSubmissionId": uncached_submission.hashid,
             },
         )
 
@@ -346,9 +295,6 @@ def test_frontend_search_events_query_keeps_participants_scoped_by_conference(
                 }
             ]
         },
-        "uncachedSubmission": {
-            "speaker": {"participant": {"speakerAvailabilities": {"uncached": True}}}
-        },
         "second": {
             "results": [
                 {
@@ -361,42 +307,6 @@ def test_frontend_search_events_query_keeps_participants_scoped_by_conference(
     }
 
 
-def test_frontend_search_events_query_reuses_cached_participants(
-    admin_graphql_api_client,
-    admin_superuser,
-):
-    conference = ConferenceFactory()
-    keynote = KeynoteFactory(
-        conference=conference,
-        title=LazyI18nString({"en": "Cached Keynote", "it": ""}),
-    )
-    speaker = KeynoteSpeakerFactory(keynote=keynote).user
-    ParticipantFactory(
-        conference=conference,
-        user=speaker,
-        speaker_availabilities={"cached": True},
-    )
-
-    admin_graphql_api_client.force_login(admin_superuser)
-    with CaptureQueriesContext(connection) as queries:
-        response = admin_graphql_api_client.query(
-            CACHED_PARTICIPANT_SEARCH_EVENTS_QUERY,
-            variables={
-                "code": conference.code,
-                "conferenceId": str(conference.id),
-            },
-        )
-
-    participant_table = participant_models.Participant._meta.db_table
-    assert sum(f'FROM "{participant_table}"' in query["sql"] for query in queries) == 1
-    assert "errors" not in response
-    participant = {"participant": {"speakerAvailabilities": {"cached": True}}}
-    assert response["data"] == {
-        "conference": {"keynotes": [{"speakers": [participant]}]},
-        "searchEventsForSchedule": {"results": [{"speakers": [participant]}]},
-    }
-
-
 @pytest.mark.parametrize("user_to_test", ["admin_user", "user", "not_authenticated"])
 def test_cannot_search_without_permission(
     admin_graphql_api_client,

backend/api/schedule/types/schedule_item.py

@@ -12,7 +12,6 @@
 from api.schedule.types.room import Room
 from api.schedule.types.schedule_item_user import ScheduleItemUser
 from api.submissions.types import Submission
-from participants import models as participant_models
 from schedule import models
 
 if TYPE_CHECKING:  # pragma: no cover
@@ -168,43 +167,12 @@ def user_is_talk_manager(self, info: Info) -> bool:
         only=["conference_id"],
         select_related=["submission__speaker"],
         prefetch_related=[
-            "keynote__speakers__user",
-            "additional_speakers__user",
+            "submission__speaker__participants",
+            "keynote__speakers__user__participants",
+            "additional_speakers__user__participants",
         ],
     )
-    def speakers(self, info: Info) -> list[ScheduleItemUser]:
-        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, {}
-        )
-        loaded_conferences = info.context._schedule_participants_loaded_conferences
-        if self.conference_id not in loaded_conferences:
-            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")
-                }
-            )
-            loaded_conferences.add(self.conference_id)
-
+    def speakers(self) -> list[ScheduleItemUser]:
         schedule_item_speakers = []
         if self.submission_id:
             schedule_item_speakers.append(self.submission.speaker)
@@ -228,7 +196,14 @@ def speakers(self, info: Info) -> list[ScheduleItemUser]:
                     id=speaker.id,
                     fullname=speaker.fullname,
                     full_name=speaker.full_name,
-                    participant=participants_data.get(speaker.id),
+                    participant=next(
+                        (
+                            participant
+                            for participant in speaker.participants.all()
+                            if participant.conference_id == self.conference_id
+                        ),
+                        None,
+                    ),
                 )
             )