fix: inconsistent loading of discussion thread response

Author: naincy128

lms/djangoapps/discussion/rest_api/api.py

@@ -5,6 +5,7 @@
 
 from __future__ import annotations
 
+import itertools
 import logging
 import re
 from collections import defaultdict
@@ -1235,58 +1236,6 @@ def _serialize_discussion_entities(
     return results
 
 
-def _prefetch_author_data_into_context(context, content_items):
-    """
-    Bulk-prefetch User objects, Role assignments, and GlobalStaff status
-    for all content authors and inject into serializer context.
-
-    This eliminates N+1 DB queries in CommentSerializer.get_author(),
-    _get_user_label(), _get_user_labels_all(), and get_learner_status().
-    """
-    author_ids = set()
-    for item in content_items:
-        uid = item.get("user_id")
-        if uid:
-            try:
-                author_ids.add(int(uid))
-            except (ValueError, TypeError):
-                pass
-
-    if not author_ids:
-        return
-
-    # 1. Bulk fetch User objects (1 query instead of N)
-    users_by_id = {
-        u.id: u
-        for u in User.objects.filter(id__in=author_ids).only("id", "username")
-    }
-    context["_prefetched_users"] = users_by_id
-
-    # 2. Bulk fetch Role assignments
-    roles_by_user = defaultdict(set)
-    for uid, name in Role.objects.filter(
-        users__id__in=author_ids,
-        course_id=context["course"].id,
-        name__in=[
-            FORUM_ROLE_ADMINISTRATOR,
-            FORUM_ROLE_MODERATOR,
-            FORUM_ROLE_COMMUNITY_TA,
-            FORUM_ROLE_GROUP_MODERATOR,
-        ],
-    ).values_list("users__id", "name"):
-        roles_by_user[int(uid)].add(name)
-    context["_prefetched_roles"] = dict(roles_by_user)
-
-    # 3. Bulk check GlobalStaff (1 check per user, but from cached User objects)
-    from common.djangoapps.student.roles import GlobalStaff
-    global_staff_checker = GlobalStaff()
-    global_staff_ids = set()
-    for uid, user in users_by_id.items():
-        if global_staff_checker.has_user(user):
-            global_staff_ids.add(uid)
-    context["_prefetched_global_staff_ids"] = global_staff_ids
-
-
 def get_thread_list(  # pylint: disable=too-many-statements
     request: Request,
     course_key: CourseKey,
@@ -2318,74 +2267,56 @@ def get_thread(request, thread_id, requested_fields=None, course_id=None):
     )[0]
 
 
-def _normalize_forum_comment(raw_comment):
-    """
-    Normalize a Comment.to_dict() output from the forum MySQL backend
-    to match the key format expected by CommentSerializer and permissions.py.
-
-    The MySQL backend's Comment.to_dict() uses keys like:
-        _id, _type, author_id, author_username, comment_thread_id
-    But CommentSerializer (via _ContentSerializer) and get_editable_fields expect:
-        id, type, user_id, username, thread_id
+def get_response_comments(request, comment_id, page, page_size, requested_fields=None, include_muted=False):
     """
-    if not isinstance(raw_comment, dict):
-        return raw_comment
-
-    normalized = dict(raw_comment)
+    Return the list of comments for the given thread response.
 
-    if "_id" in normalized and "id" not in normalized:
-        normalized["id"] = normalized["_id"]
+    Arguments:
 
-    if "_type" in normalized and "type" not in normalized:
-        normalized["type"] = normalized["_type"].lower()
+        request: The django request object used for build_absolute_uri and
+          determining the requesting user.
 
-    if "author_id" in normalized and "user_id" not in normalized:
-        normalized["user_id"] = normalized["author_id"]
+        comment_id: The id of the comment/response to get child comments for.
 
-    if "author_username" in normalized and "username" not in normalized:
-        normalized["username"] = normalized["author_username"]
+        page: The page number (1-indexed) to retrieve
 
-    if "comment_thread_id" in normalized and "thread_id" not in normalized:
-        normalized["thread_id"] = normalized["comment_thread_id"]
+        page_size: The number of comments to retrieve per page
 
-    if "children" not in normalized:
-        normalized["children"] = []
+        requested_fields: Indicates which additional fields to return for
+        each child comment. (i.e. ['profile_image'])
 
-    return normalized
+    Returns:
 
+        A paginated result containing a list of comments
 
-def get_response_comments(request, comment_id, page, page_size, requested_fields=None, include_muted=False):
-    """
-    Return the list of comments for the given thread response.
-    Uses direct backend queries for efficient DB-level pagination
-    instead of loading the entire thread recursively.
     """
     try:
         cc_comment = Comment(id=comment_id).retrieve()
-
         reverse_order = request.GET.get("reverse_order", False)
-        reverse_order = reverse_order in ["true", "True", True]
         show_deleted = request.GET.get("show_deleted", False)
         show_deleted = show_deleted in ["true", "True", True]
 
         cc_thread, context = _get_thread_and_context(
             request,
             cc_comment["thread_id"],
             retrieve_kwargs={
-                "with_responses": False,
-                "recursive": False,
+                "with_responses": True,
+                "recursive": True,
+                "reverse_order": reverse_order,
+                "show_deleted": show_deleted,
             },
         )
-
-        if show_deleted and not context["has_moderation_privilege"]:
-            raise PermissionDenied(
-                "`show_deleted` can only be set by users with moderation roles."
+        if cc_thread["thread_type"] == "question":
+            thread_responses = itertools.chain(
+                cc_thread["endorsed_responses"], cc_thread["non_endorsed_responses"]
             )
-
-        from forum.backend import get_backend
-
-        course_id = cc_thread["course_id"]
-        backend = get_backend(course_id)()
+        else:
+            thread_responses = cc_thread["children"]
+        response_comments = []
+        for response in thread_responses:
+            if response["id"] == comment_id:
+                response_comments = response["children"]
+                break
 
         # Filter deleted content from the FULL list first
         if not show_deleted:
@@ -2428,20 +2359,15 @@ def get_response_comments(request, comment_id, page, page_size, requested_fields
         results = _serialize_discussion_entities(
             request,
             context,
-            response_comments,
+            paged_response_comments,
             requested_fields,
             DiscussionEntity.comment,
         )
 
         paginator = DiscussionAPIPagination(
-            request,
-            page,
-            num_pages,
-            total_comments_count,
+            request, page, num_pages, total_comments_count
         )
-
         return paginator.get_paginated_response(results)
-
     except CommentClientRequestError as err:
         raise CommentNotFoundError("Comment not found") from err
 
@@ -3266,4 +3192,4 @@ def get_deleted_content_for_course(
 
     except Exception as e:
         log.exception("Error getting deleted content for course %s: %s", course_id, e)
-        raise
+        raise