feat: implement sorting functionality for user retrieval in API views

Author: BryanttV

openedx_authz/rest_api/enums.py

@@ -0,0 +1,27 @@
+"""Enums for the Open edX AuthZ REST API."""
+
+from enum import Enum
+
+
+class BaseEnum(str, Enum):
+    """Base enum class."""
+
+    @classmethod
+    def values(cls):
+        """List the values of the enum."""
+        return [e.value for e in cls]
+
+
+class SortField(BaseEnum):
+    """Enum for the fields to sort by."""
+
+    USERNAME = "username"
+    FULL_NAME = "full_name"
+    EMAIL = "email"
+
+
+class SortOrder(BaseEnum):
+    """Enum for the order to sort by."""
+
+    ASC = "asc"
+    DESC = "desc"

openedx_authz/rest_api/utils.py

@@ -6,6 +6,8 @@
 from edx_rest_framework_extensions.auth.session.authentication import SessionAuthenticationAllowInactiveUser
 from rest_framework.permissions import IsAuthenticated
 
+from openedx_authz.rest_api.enums import SortField, SortOrder
+
 User = get_user_model()
 
 
@@ -48,3 +50,31 @@ def get_user_by_username_or_email(username_or_email: str) -> User:
     if hasattr(user, "userretirementrequest"):
         raise User.DoesNotExist
     return user
+
+
+def sort_users(
+    users: list[dict], sort_by: SortField = SortField.USERNAME, order: SortOrder = SortOrder.ASC
+) -> list[dict]:
+    """
+    Sort users by a given field and order.
+
+    Args:
+        users (list[dict]): The users to sort.
+        sort_by (SortField, optional): The field to sort by. Defaults to SortField.USERNAME.
+        order (SortOrder, optional): The order to sort by. Defaults to SortOrder.ASC.
+
+    Raises:
+        ValueError: If the sort field is invalid.
+        ValueError: If the sort order is invalid.
+
+    Returns:
+        list[dict]: The sorted users.
+    """
+    if sort_by not in SortField.values():
+        raise ValueError(f"Invalid field: '{sort_by}'. Must be one of {SortField.values()}")
+
+    if order not in SortOrder.values():
+        raise ValueError(f"Invalid order: '{order}'. Must be one of {SortOrder.values()}")
+
+    sorted_users = sorted(users, key=lambda user: (user[sort_by] or "").lower(), reverse=order == SortOrder.DESC)
+    return sorted_users

openedx_authz/rest_api/v1/serializers.py

@@ -2,21 +2,10 @@
 
 from rest_framework import serializers
 
+from openedx_authz.rest_api.enums import SortField, SortOrder
 from openedx_authz.rest_api.utils import get_user_by_username_or_email
 from openedx_authz.rest_api.v1.fields import CommaSeparatedListField
 
-__all__ = [
-    "PermissionValidationSerializer",
-    "PermissionValidationResponseSerializer",
-    "AddUserToRoleWithScopeSerializer",
-    "RemoveUserFromRoleWithScopeSerializer",
-    "ListUsersInRoleWithScopeSerializer",
-    "ListRolesWithScopeSerializer",
-    "ListUsersInRoleWithScopeResponseSerializer",
-    "ListRolesWithScopeResponseSerializer",
-    "RoleAssignmentSerializer",
-]
-
 
 class ScopeMixin(serializers.Serializer):  # pylint: disable=abstract-method
     """Mixin providing scope field functionality."""
@@ -62,6 +51,8 @@ class ListUsersInRoleWithScopeSerializer(ScopeMixin):  # pylint: disable=abstrac
     """Serializer for listing users in a role with a scope."""
 
     roles = CommaSeparatedListField(required=False)
+    sort_by = serializers.ChoiceField(required=False, choices=[(e.value, e.name) for e in SortField])
+    order = serializers.ChoiceField(required=False, choices=[(e.value, e.name) for e in SortOrder])
 
 
 class ListRolesWithScopeSerializer(ScopeMixin):  # pylint: disable=abstract-method

openedx_authz/rest_api/v1/views.py

@@ -15,7 +15,8 @@
 from rest_framework.views import APIView
 
 from openedx_authz import api
-from openedx_authz.rest_api.utils import get_user_by_username_or_email, view_auth_classes
+from openedx_authz.rest_api.enums import SortField, SortOrder
+from openedx_authz.rest_api.utils import get_user_by_username_or_email, sort_users, view_auth_classes
 from openedx_authz.rest_api.v1.paginators import AuthZAPIViewPagination
 from openedx_authz.rest_api.v1.serializers import (
     AddUserToRoleWithScopeSerializer,
@@ -92,6 +93,8 @@ class RoleUserAPIView(APIView):
             apidocs.query_parameter("scope", str, description="The authorization scope for the role"),
             apidocs.query_parameter("page", int, description="Page number for pagination"),
             apidocs.query_parameter("page_size", int, description="Number of items per page"),
+            apidocs.query_parameter("sort_by", str, description="The field to sort by"),
+            apidocs.query_parameter("order", str, description="The order to sort by"),
         ],
         responses={
             status.HTTP_200_OK: "The users were retrieved successfully",
@@ -101,16 +104,20 @@ class RoleUserAPIView(APIView):
     )
     def get(self, request: HttpRequest) -> Response:
         """Retrieve all users with role assignments within a specific scope."""
-        # TODO: Filter by role
         serializer = ListUsersInRoleWithScopeSerializer(data=request.query_params)
         serializer.is_valid(raise_exception=True)
         user_role_assignments = api.get_all_user_role_assignments_in_scope_v2(serializer.validated_data["scope"])
 
         paginator = self.pagination_class()
         paginated_assignments = paginator.paginate_queryset(user_role_assignments, request)
 
-        serializer = RoleAssignmentSerializer(paginated_assignments, many=True)
-        return paginator.get_paginated_response(serializer.data)
+        response_serializer = RoleAssignmentSerializer(paginated_assignments, many=True)
+
+        sort_by = serializer.validated_data.get("sort_by", SortField.USERNAME)
+        order = serializer.validated_data.get("order", SortOrder.ASC)
+        user_role_assignments = sort_users(response_serializer.data, sort_by, order)
+
+        return paginator.get_paginated_response(user_role_assignments)
 
     @apidocs.schema(
         body=AddUserToRoleWithScopeSerializer,