Backend: Enhance participant team download functionality to support JSON format and optimize queries (#4962)

* Backend: Enhance participant team download functionality to support JSON format and optimize queries

* Refactor download_all_participants view to change query parameter from 'format' to 'output' for consistency. Update related unit tests to reflect this change and ensure proper functionality for JSON and CSV responses.

Author: RishabhJain2018

apps/analytics/views.py

@@ -328,18 +328,38 @@ def get_challenge_phase_submission_analysis(
 @authentication_classes((JWTAuthentication, ExpiringTokenAuthentication))
 def download_all_participants(request, challenge_pk):
     """
-    Returns the List of Participant Teams and its details in csv format
+    Returns the List of Participant Teams and its details.
+
+    Query Parameters:
+        output (optional): Response format - 'json' or 'csv' (default: 'csv').
+
+    Returns:
+        - If output=json: JSON response with participant teams data
+        - If output=csv (default): CSV file download with participant teams data
     """
     if is_user_a_host_of_challenge(
         user=request.user, challenge_pk=challenge_pk
     ):
         challenge = get_challenge_model(challenge_pk)
-        participant_teams = challenge.participant_teams.all().order_by(
-            "-team_name"
-        )
+        # Use prefetch_related to avoid N+1 queries when accessing
+        # participants and their user data in the serializer
+        participant_teams = challenge.participant_teams.prefetch_related(
+            "participants__user"
+        ).order_by("-team_name")
         teams = ChallengeParticipantSerializer(
             participant_teams, many=True, context={"request": request}
         )
+
+        response_format = request.query_params.get("output", "csv").lower()
+
+        if response_format == "json":
+            response_data = {
+                "participant_teams": teams.data,
+                "count": len(teams.data),
+            }
+            return Response(response_data, status=status.HTTP_200_OK)
+
+        # Default: Return CSV format
         response = HttpResponse(content_type="text/csv")
         response["Content-Disposition"] = (
             "attachment; filename=participant_teams_{0}.csv".format(

apps/participants/serializers.py

@@ -1,5 +1,4 @@
 from accounts.serializers import UserProfileSerializer
-from challenges.models import Challenge
 from challenges.serializers import ChallengeSerializer
 from django.contrib.auth.models import User
 from django.utils import timezone
@@ -174,47 +173,41 @@ class ParticipantCountSerializer(serializers.Serializer):
 
 
 class ChallengeParticipantSerializer(serializers.Serializer):
+    """
+    Serializer for participant teams in challenge analytics.
+
+    Note: For optimal performance, the queryset passed to this serializer
+    should use prefetch_related('participants__user') to avoid N+1 queries.
+    """
+
     team_name = serializers.SerializerMethodField()
     team_members = serializers.SerializerMethodField()
     team_members_email_ids = serializers.SerializerMethodField()
 
     class Meta:
-        model = Challenge
+        model = ParticipantTeam
         fields = ("team_name", "team_members", "team_members_email_ids")
 
     def get_team_name(self, obj):
         return obj.team_name
 
     def get_team_members(self, obj):
-        try:
-            participant_team = ParticipantTeam.objects.get(
-                team_name=obj.team_name
-            )
-        except ParticipantTeam.DoesNotExist:
-            return "Participant team does not exist"
-
-        participant_ids = Participant.objects.filter(
-            team=participant_team
-        ).values_list("user_id", flat=True)
-        return list(
-            User.objects.filter(id__in=participant_ids).values_list(
-                "username", flat=True
-            )
-        )
+        """
+        Get list of usernames for all participants in the team.
+        Uses prefetched data if available to avoid additional queries.
+        """
+        # Use prefetched participants if available (no additional query)
+        # obj.participants is the related_name from Participant.team
+        return [
+            participant.user.username for participant in obj.participants.all()
+        ]
 
     def get_team_members_email_ids(self, obj):
-        try:
-            participant_team = ParticipantTeam.objects.get(
-                team_name=obj.team_name
-            )
-        except ParticipantTeam.DoesNotExist:
-            return "Participant team does not exist"
-
-        participant_ids = Participant.objects.filter(
-            team=participant_team
-        ).values_list("user_id", flat=True)
-        return list(
-            User.objects.filter(id__in=participant_ids).values_list(
-                "email", flat=True
-            )
-        )
+        """
+        Get list of email addresses for all participants in the team.
+        Uses prefetched data if available to avoid additional queries.
+        """
+        # Use prefetched participants if available (no additional query)
+        return [
+            participant.user.email for participant in obj.participants.all()
+        ]

tests/unit/analytics/test_views.py

@@ -964,18 +964,23 @@ def setUp(self):
             is_public=True,
         )
 
+    def _get_expected_participant_teams_queryset(self):
+        """Helper to get participant teams with prefetch for serializer"""
+        challenge = get_challenge_model(self.challenge.pk)
+        return challenge.participant_teams.prefetch_related(
+            "participants__user"
+        ).order_by("-team_name")
+
     def test_host_downloads_participant_team(self):
+        """Test that host can download participant teams as CSV"""
         expected = io.StringIO()
         expected_participant_teams = csv.writer(
             expected, quoting=csv.QUOTE_ALL
         )
         expected_participant_teams.writerow(
             ["Team Name", "Team Members", "Email Id"]
         )
-        challenge = get_challenge_model(self.challenge.pk)
-        participant_team = challenge.participant_teams.all().order_by(
-            "-team_name"
-        )
+        participant_team = self._get_expected_participant_teams_queryset()
         participant_teams = ChallengeParticipantSerializer(
             participant_team, many=True
         )
@@ -993,10 +998,136 @@ def test_host_downloads_participant_team(self):
         self.assertEqual(response.status_code, status.HTTP_200_OK)
 
     def test_user_not_host_downloads_participant_team(self):
+        """Test that non-host user cannot download participant teams"""
         expected = {
             "error": "Sorry, you are not authorized to make this request"
         }
         self.client.force_authenticate(user=self.user2)
         response = self.client.get(self.url, {})
         self.assertEqual(response.data, expected)
         self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
+
+    def test_host_gets_participant_team_json_format(self):
+        """Test that host can get participant teams in JSON format"""
+        participant_team = self._get_expected_participant_teams_queryset()
+        participant_teams = ChallengeParticipantSerializer(
+            participant_team, many=True
+        )
+        expected = {
+            "participant_teams": participant_teams.data,
+            "count": len(participant_teams.data),
+        }
+        self.client.force_authenticate(user=self.user)
+        response = self.client.get(self.url, {"output": "json"})
+        self.assertEqual(response.data, expected)
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+
+    def test_user_not_host_gets_participant_team_json_format(self):
+        """Test that non-host user cannot get participant teams in JSON format"""
+        expected = {
+            "error": "Sorry, you are not authorized to make this request"
+        }
+        self.client.force_authenticate(user=self.user2)
+        response = self.client.get(self.url, {"output": "json"})
+        self.assertEqual(response.data, expected)
+        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
+
+    def test_json_format_case_insensitive(self):
+        """Test that output parameter is case-insensitive"""
+        self.client.force_authenticate(user=self.user)
+
+        # Test uppercase (use 'output' to avoid DRF format content negotiation)
+        response = self.client.get(self.url, {"output": "JSON"})
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertIn("participant_teams", response.data)
+        self.assertIn("count", response.data)
+
+        # Test mixed case
+        response = self.client.get(self.url, {"output": "Json"})
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertIn("participant_teams", response.data)
+
+    def test_invalid_format_defaults_to_csv(self):
+        """Test that invalid output parameter defaults to CSV download"""
+        self.client.force_authenticate(user=self.user)
+        response = self.client.get(self.url, {"output": "invalid"})
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertEqual(response["Content-Type"], "text/csv")
+        self.assertIn("attachment; filename=", response["Content-Disposition"])
+
+    def test_json_response_structure(self):
+        """Test that JSON response has correct structure"""
+        self.client.force_authenticate(user=self.user)
+        response = self.client.get(self.url, {"output": "json"})
+
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertIn("participant_teams", response.data)
+        self.assertIn("count", response.data)
+        self.assertEqual(response.data["count"], 2)  # Two teams added in setUp
+
+        # Verify each team has required fields
+        for team in response.data["participant_teams"]:
+            self.assertIn("team_name", team)
+            self.assertIn("team_members", team)
+            self.assertIn("team_members_email_ids", team)
+            self.assertIsInstance(team["team_members"], list)
+            self.assertIsInstance(team["team_members_email_ids"], list)
+
+    def test_json_response_contains_correct_data(self):
+        """Test that JSON response contains correct participant data"""
+        self.client.force_authenticate(user=self.user)
+        response = self.client.get(self.url, {"output": "json"})
+
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+
+        # Find participant_team in response
+        team_names = [
+            team["team_name"] for team in response.data["participant_teams"]
+        ]
+        self.assertIn("Participant Team", team_names)
+        self.assertIn("Participant Team3", team_names)
+
+        # Verify member data for participant_team
+        for team in response.data["participant_teams"]:
+            if team["team_name"] == "Participant Team":
+                self.assertIn("otheruser", team["team_members"])
+                self.assertIn(
+                    "otheruser@test.com", team["team_members_email_ids"]
+                )
+            elif team["team_name"] == "Participant Team3":
+                self.assertIn("user3", team["team_members"])
+                self.assertIn("user3@test.com", team["team_members_email_ids"])
+
+    def test_csv_response_headers(self):
+        """Test that CSV response has correct headers"""
+        self.client.force_authenticate(user=self.user)
+        response = self.client.get(self.url, {})
+
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertEqual(response["Content-Type"], "text/csv")
+        self.assertIn(
+            "participant_teams_{}.csv".format(self.challenge.pk),
+            response["Content-Disposition"],
+        )
+
+    def test_empty_participant_teams(self):
+        """Test response when challenge has no participant teams"""
+        # Remove all participant teams
+        self.challenge.participant_teams.clear()
+
+        self.client.force_authenticate(user=self.user)
+
+        # Test JSON format
+        response = self.client.get(self.url, {"output": "json"})
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertEqual(response.data["participant_teams"], [])
+        self.assertEqual(response.data["count"], 0)
+
+        # Test CSV format
+        response = self.client.get(self.url, {})
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        content = response.content.decode("utf-8")
+        # Should only have header row
+        lines = content.strip().split("\n")
+        self.assertEqual(len(lines), 1)
+        self.assertIn("Team Name", lines[0])

tests/unit/participants/test_serializers.py

@@ -11,22 +11,60 @@
 from rest_framework import serializers
 
 
-class DummyObj:
-    team_name = "nonexistent_team"
+class TestChallengeParticipantSerializer(TestCase):
+    """Tests for ChallengeParticipantSerializer (expects ParticipantTeam with participants)."""
 
+    def setUp(self):
+        self.user = User.objects.create(
+            username="testuser",
+            email="test@example.com",
+        )
+        self.empty_team = ParticipantTeam.objects.create(
+            team_name="Empty Team",
+            created_by=self.user,
+        )
 
-class TestChallengeParticipantSerializer(TestCase):
-    def test_get_team_members_team_does_not_exist(self):
+    def test_get_team_members_empty_team(self):
+        """Team with no participants returns empty list."""
         serializer = ChallengeParticipantSerializer()
-        obj = DummyObj()
-        result = serializer.get_team_members(obj)
-        self.assertEqual(result, "Participant team does not exist")
+        result = serializer.get_team_members(self.empty_team)
+        self.assertEqual(result, [])
 
-    def test_get_team_members_email_ids_team_does_not_exist(self):
+    def test_get_team_members_email_ids_empty_team(self):
+        """Team with no participants returns empty email list."""
+        serializer = ChallengeParticipantSerializer()
+        result = serializer.get_team_members_email_ids(self.empty_team)
+        self.assertEqual(result, [])
+
+    def test_get_team_members_with_participants(self):
+        """Team with participants returns usernames."""
+        participant_user = User.objects.create(
+            username="member1",
+            email="member1@example.com",
+        )
+        Participant.objects.create(
+            user=participant_user,
+            status=Participant.SELF,
+            team=self.empty_team,
+        )
+        serializer = ChallengeParticipantSerializer()
+        result = serializer.get_team_members(self.empty_team)
+        self.assertEqual(result, ["member1"])
+
+    def test_get_team_members_email_ids_with_participants(self):
+        """Team with participants returns emails."""
+        participant_user = User.objects.create(
+            username="member1",
+            email="member1@example.com",
+        )
+        Participant.objects.create(
+            user=participant_user,
+            status=Participant.SELF,
+            team=self.empty_team,
+        )
         serializer = ChallengeParticipantSerializer()
-        obj = DummyObj()
-        result = serializer.get_team_members_email_ids(obj)
-        self.assertEqual(result, "Participant team does not exist")
+        result = serializer.get_team_members_email_ids(self.empty_team)
+        self.assertEqual(result, ["member1@example.com"])
 
 
 class TestInviteParticipantToTeamSerializer(TestCase):