Merge pull request #300 from AI4Bharat/Pref_anno

minor fix in unassigned review task

Author: ishvindersethi22

backend/projects/views.py

@@ -114,6 +114,55 @@ def batch(iterable, n=1):
         yield iterable[ndx : min(ndx + n, l)]
 
 
+def auto_update_reviewer_preferred_annotators(project, new_annotator_ids, requesting_user=None):
+    """
+    After an annotator is added (or un-frozen) in a project, newly added annotators
+    are added to the preferred annotators list of all annotation reviewers if all were selected,
+    otherwise not preferred for logged in user as well as reviewers
+    """
+    project_id_str = str(project.id)
+    new_ids_set = set(new_annotator_ids)
+
+    frozen_user_ids = set(project.frozen_users.values_list("id", flat=True))
+    all_active_ids = set(
+        project.annotators.exclude(id__in=frozen_user_ids).values_list("id", flat=True)
+    )
+    previous_annotator_ids = all_active_ids - new_ids_set
+
+    users_to_update = set(project.annotation_reviewers.all())
+    if requesting_user:
+        users_to_update.add(requesting_user)
+
+    for user in users_to_update:
+        prefs = user.preferred_task_by_json or {}
+        if not isinstance(prefs, dict):
+            prefs = {}
+        preferred_annotators = prefs.get("preferred_annotators", {})
+        if not isinstance(preferred_annotators, dict):
+            preferred_annotators = {}
+
+        saved_ids = set(int(x) for x in preferred_annotators.get(project_id_str, []))
+        previous_ids_int = set(int(x) for x in previous_annotator_ids)
+
+        if len(saved_ids) == 0:
+            continue
+
+        saved_ids_clean = saved_ids - set(int(x) for x in new_ids_set)
+        saved_active_ids = saved_ids_clean.intersection(previous_ids_int)
+        was_all_selected = (saved_active_ids == previous_ids_int)
+
+        if was_all_selected:
+            final_saved_ids = saved_ids_clean | set(int(x) for x in new_ids_set)
+        else:
+            final_saved_ids = saved_ids_clean
+
+        if final_saved_ids != saved_ids:
+            preferred_annotators[project_id_str] = list(final_saved_ids)
+            prefs["preferred_annotators"] = preferred_annotators
+            user.preferred_task_by_json = prefs
+            user.save(update_fields=["preferred_task_by_json"])
+
+
 def get_review_reports(proj_id, userid, start_date, end_date):
     user = User.objects.get(id=userid)
     userName = user.username
@@ -1549,6 +1598,8 @@ def remove_frozen_user(self, request, pk=None):
                 user = User.objects.get(pk=user_id)
                 project.frozen_users.remove(user)
                 project.save()
+                auto_update_reviewer_preferred_annotators(project, [user.id], requesting_user=request.user)
+
             return Response(
                 {"message": "Frozen User removed from the project"},
                 status=status.HTTP_200_OK,
@@ -3848,6 +3899,8 @@ def add_project_annotators(self, request, pk=None, *args, **kwargs):
                 project.annotators.add(annotator)
                 project.save()
 
+                auto_update_reviewer_preferred_annotators(project, [annotator.id], requesting_user=request.user)
+
                 # Creating Notification
                 title = f"{project.title}:{project.id} New annotators have been added to the project"
                 notification_type = "add_member"
@@ -3912,6 +3965,30 @@ def add_project_reviewers(self, request, pk, *args, **kwargs):
 
                 project.annotation_reviewers.add(user)
                 project.save()
+                project_id_str = str(project.id)
+                frozen_user_ids = set(project.frozen_users.values_list("id", flat=True))
+                all_active_annotator_ids = set(
+                    project.annotators.exclude(id__in=frozen_user_ids).values_list("id", flat=True)
+                )
+
+                users_to_update = {user}
+
+                for u in users_to_update:
+                    prefs = u.preferred_task_by_json or {}
+                    if not isinstance(prefs, dict):
+                        prefs = {}
+                    preferred_annotators = prefs.get("preferred_annotators", {})
+                    if not isinstance(preferred_annotators, dict):
+                        preferred_annotators = {}
+                    
+                    saved_ids = set(int(x) for x in preferred_annotators.get(project_id_str, []))
+                    saved_ids.update(all_active_annotator_ids)
+                    
+                    preferred_annotators[project_id_str] = list(saved_ids)
+                    prefs["preferred_annotators"] = preferred_annotators
+                    u.preferred_task_by_json = prefs
+                    u.save(update_fields=["preferred_task_by_json"])
+
                 # Creating Notification
                 title = f"{project.title}:{project.id} New reviewers have been added to project"
                 notification_type = "add_member"

backend/tasks/views.py

@@ -112,8 +112,8 @@ class TaskViewSet(viewsets.ModelViewSet, mixins.ListModelMixin):
     )
     def unassigned_review_summary(self, request):
         """
-        Returns a summary of unassigned review tasks grouped by annotator,
-        including the list of unassigned task IDs.
+        Returns a summary of unassigned review tasks grouped by annotator.
+        Shows ALL annotators in the project, even those with 0 unassigned tasks.
         """
         project_id = request.query_params.get("project_id")
         if not project_id:
@@ -122,40 +122,60 @@ def unassigned_review_summary(self, request):
                 status=status.HTTP_400_BAD_REQUEST,
             )
 
-        cur_user = request.user  # current logged-in user
+        try:
+            project = Project.objects.get(pk=project_id)
+        except Project.DoesNotExist:
+            return Response(
+                {"error": "Project not found"},
+                status=status.HTTP_404_NOT_FOUND,
+            )
+
+        cur_user = request.user
 
-        tasks = (
+        frozen_user_ids = project.frozen_users.values_list("id", flat=True)
+        all_annotators = project.annotators.exclude(id__in=frozen_user_ids)
+
+        unassigned_tasks = (
             Task.objects.filter(project_id=project_id)
             .filter(task_status=ANNOTATED)
             .filter(review_user__isnull=True)
             .exclude(annotation_users=cur_user.id)
             .distinct()
         )
 
-        data = (
-            tasks.values(
-                "annotations__completed_by__id",
-                "annotations__completed_by__email",
-                "annotations__completed_by__username"
+        from tasks.models import Annotation as Annotation_model, ANNOTATOR_ANNOTATION
+        annotator_task_counts = (
+            Annotation_model.objects.filter(
+                task__in=unassigned_tasks,
+                annotation_type=ANNOTATOR_ANNOTATION,
+                completed_by__in=all_annotators,
             )
+            .values("completed_by__id")
             .annotate(
-                unassigned_count=Count("id"),
-                task_ids=ArrayAgg("id", distinct=True),
+                unassigned_count=Count("task", distinct=True),
+                task_ids=ArrayAgg("task_id", distinct=True),
             )
-            .order_by("-unassigned_count")
         )
 
-        result = [
-            {
-                "annotator_id": item["annotations__completed_by__id"],
-                "annotator_username": item["annotations__completed_by__username"],
-                "annotator_email": item["annotations__completed_by__email"],
+        count_lookup = {}
+        for item in annotator_task_counts:
+            count_lookup[item["completed_by__id"]] = {
                 "unassigned_count": item["unassigned_count"],
                 "task_ids": item["task_ids"],
             }
-            for item in data
-            if item["annotations__completed_by__id"] is not None
-        ]
+
+        result = []
+        for annotator in all_annotators:
+            counts = count_lookup.get(annotator.id, {"unassigned_count": 0, "task_ids": []})
+            result.append({
+                "annotator_id": annotator.id,
+                "annotator_email": annotator.email,
+                "annotator_username": annotator.username,
+                "unassigned_count": counts["unassigned_count"],
+                "task_ids": counts["task_ids"],
+            })
+
+        result.sort(key=lambda x: x["unassigned_count"], reverse=True)
 
         return Response(result, status=status.HTTP_200_OK)
 

backend/users/serializers.py

@@ -120,6 +120,7 @@ class Meta:
             "participation_type",
             "prefer_cl_ui",
             "is_active",
+            "preferred_task_by_json",
         ]
         read_only_fields = [
             "id",