Added accounts app admin filters.

These filters support filtering users, profiles and availability
based on a user's session membership and djangonaut participation.

These aren't necessarily helpful to a session organizer, but are
helpful to admins or people managing the community from a more
global perspective.

Author: tim-schilling

accounts/admin.py

@@ -9,16 +9,70 @@
 from django.contrib.auth.models import Group
 from django.contrib import admin as django_admin
 from django.core.management import call_command
+from django.db.models import Exists, OuterRef, QuerySet
 from django.http import HttpResponse, HttpResponseRedirect
 from django.urls import reverse
 
-from accounts.models import CustomUser
-from accounts.models import Link
-from accounts.models import UserAvailability
-from accounts.models import UserProfile
+from accounts.models import CustomUser, Link, UserAvailability, UserProfile
+from home.models.session import SessionMembership
 from indymeet.admin import DescriptiveSearchMixin
 
 
+class PastSessionMembershipFilter(admin.SimpleListFilter):
+    """Base filter for users with a membership in a past session.
+
+    Subclasses set ``title``, ``parameter_name``, and optionally override
+    ``membership_queryset``.  Set ``user_field`` to the FK path from the
+    filtered model to the user (empty string when the model *is* the user).
+    """
+
+    title: str
+    parameter_name: str
+    user_field: str = ""
+    membership_queryset = SessionMembership.objects.all()
+
+    def lookups(
+        self, request: admin.ModelAdmin, model_admin: admin.ModelAdmin
+    ) -> list[tuple[str, str]]:
+        return [
+            ("yes", "Yes"),
+            ("no", "No"),
+        ]
+
+    def queryset(self, request: admin.ModelAdmin, queryset: QuerySet) -> QuerySet:
+        if self.value() not in ("yes", "no"):
+            return queryset
+
+        outer_ref = self.user_field or "pk"
+        annotated = queryset.annotate(
+            **{
+                self.parameter_name: Exists(
+                    self.membership_queryset.filter(user=OuterRef(outer_ref))
+                )
+            }
+        )
+        return annotated.filter(**{self.parameter_name: self.value() == "yes"})
+
+
+class PastDjangonautFilter(PastSessionMembershipFilter):
+    title = "past djangonaut"
+    parameter_name = "past_djangonaut"
+    membership_queryset = SessionMembership.objects.djangonauts()
+
+
+class PastSessionMemberFilter(PastSessionMembershipFilter):
+    title = "past session member"
+    parameter_name = "past_session_member"
+
+
+class RelatedUserPastDjangonautFilter(PastDjangonautFilter):
+    user_field = "user"
+
+
+class RelatedUserPastSessionMemberFilter(PastSessionMemberFilter):
+    user_field = "user"
+
+
 class ExportCsvMixin:
     @admin.action(description="Export Selected")
     def export_as_csv(self, request, queryset):
@@ -73,6 +127,7 @@ class CustomUserAdmin(ExportCsvMixin, DescriptiveSearchMixin, BaseUserAdmin):
         "profile__github_username",
         "date_joined",
     )
+    list_filter = (PastDjangonautFilter, PastSessionMemberFilter)
 
     @admin.action(description="Compare availability of selected users")
     def compare_availability_action(
@@ -97,6 +152,7 @@ class UserProfileAdmin(ExportCsvMixin, DescriptiveSearchMixin, admin.ModelAdmin)
     inlines = (LinksInline,)
     model = UserProfile
     actions = ["export_as_csv"]
+    list_filter = (RelatedUserPastDjangonautFilter, RelatedUserPastSessionMemberFilter)
 
 
 @admin.register(UserAvailability)
@@ -110,6 +166,11 @@ class UserAvailabilityAdmin(DescriptiveSearchMixin, admin.ModelAdmin):
         "user__first_name",
         "user__last_name",
     )
+    list_filter = (
+        RelatedUserPastDjangonautFilter,
+        RelatedUserPastSessionMemberFilter,
+        "updated_at",
+    )
     readonly_fields = ("updated_at",)
     raw_id_fields = ("user",)
 

accounts/tests/test_admin.py

@@ -0,0 +1,136 @@
+from datetime import timedelta
+from http import HTTPStatus
+
+from django.test import TestCase
+from django.urls import reverse
+from django.utils import timezone
+
+from accounts.factories import UserAvailabilityFactory, UserFactory
+from accounts.models import CustomUser
+from home.factories import SessionFactory, SessionMembershipFactory
+from home.models import SessionMembership
+
+
+class AdminFilterTests(TestCase):
+
+    @classmethod
+    def setUpTestData(cls) -> None:
+        cls.superuser = CustomUser.objects.create_superuser(
+            username="admin", email="admin@example.com", password="test"
+        )
+        today = timezone.now().date()
+        past_session = SessionFactory.create(
+            start_date=today - timedelta(days=90),
+            end_date=today - timedelta(days=30),
+        )
+        future_session = SessionFactory.create(
+            start_date=today + timedelta(days=30),
+            end_date=today + timedelta(days=90),
+        )
+
+        cls.past_djangonaut = UserFactory.create(username="past_djangonaut")
+        SessionMembershipFactory.create(
+            user=cls.past_djangonaut,
+            session=past_session,
+            role=SessionMembership.DJANGONAUT,
+            team=None,
+        )
+
+        cls.past_navigator = UserFactory.create(username="past_navigator")
+        SessionMembershipFactory.create(
+            user=cls.past_navigator,
+            session=past_session,
+            role=SessionMembership.NAVIGATOR,
+            team=None,
+        )
+
+        cls.future_djangonaut = UserFactory.create(username="future_djangonaut")
+        SessionMembershipFactory.create(
+            user=cls.future_djangonaut,
+            session=future_session,
+            role=SessionMembership.DJANGONAUT,
+            team=None,
+        )
+
+        cls.no_session_user = UserFactory.create(username="no_session")
+
+        UserAvailabilityFactory.create(user=cls.past_djangonaut)
+        UserAvailabilityFactory.create(user=cls.no_session_user)
+
+    def setUp(self) -> None:
+        self.client.force_login(self.superuser)
+
+    def _get_filtered_values(
+        self, url: str, params: dict, field: str = "username"
+    ) -> set:
+        response = self.client.get(url, params)
+        assert response.status_code == HTTPStatus.OK
+        return set(response.context["cl"].queryset.values_list(field, flat=True))
+
+    def test_customuser_past_djangonaut_yes(self) -> None:
+        url = reverse("admin:accounts_customuser_changelist")
+        users = self._get_filtered_values(url, {"past_djangonaut": "yes"})
+        assert "past_djangonaut" in users
+        assert "future_djangonaut" in users
+        assert "past_navigator" not in users
+
+    def test_customuser_past_djangonaut_no(self) -> None:
+        url = reverse("admin:accounts_customuser_changelist")
+        users = self._get_filtered_values(url, {"past_djangonaut": "no"})
+        assert "past_djangonaut" not in users
+        assert "past_navigator" in users
+        assert "no_session" in users
+
+    def test_customuser_past_session_member_yes(self) -> None:
+        url = reverse("admin:accounts_customuser_changelist")
+        users = self._get_filtered_values(url, {"past_session_member": "yes"})
+        assert "past_djangonaut" in users
+        assert "past_navigator" in users
+        assert "future_djangonaut" in users
+        assert "no_session" not in users
+
+    def test_customuser_past_session_member_no(self) -> None:
+        url = reverse("admin:accounts_customuser_changelist")
+        users = self._get_filtered_values(url, {"past_session_member": "no"})
+        assert "past_djangonaut" not in users
+        assert "past_navigator" not in users
+        assert "no_session" in users
+
+    def test_userprofile_past_djangonaut_yes(self) -> None:
+        url = reverse("admin:accounts_userprofile_changelist")
+        user_ids = self._get_filtered_values(
+            url, {"past_djangonaut": "yes"}, field="user_id"
+        )
+        assert self.past_djangonaut.pk in user_ids
+        assert self.past_navigator.pk not in user_ids
+
+    def test_userprofile_past_session_member_yes(self) -> None:
+        url = reverse("admin:accounts_userprofile_changelist")
+        user_ids = self._get_filtered_values(
+            url, {"past_session_member": "yes"}, field="user_id"
+        )
+        assert self.past_djangonaut.pk in user_ids
+        assert self.past_navigator.pk in user_ids
+        assert self.future_djangonaut.pk in user_ids
+        assert self.no_session_user.pk not in user_ids
+
+    def test_useravailability_past_djangonaut_yes(self) -> None:
+        url = reverse("admin:accounts_useravailability_changelist")
+        user_ids = self._get_filtered_values(
+            url, {"past_djangonaut": "yes"}, field="user_id"
+        )
+        assert self.past_djangonaut.pk in user_ids
+        assert self.no_session_user.pk not in user_ids
+
+    def test_useravailability_past_session_member_no(self) -> None:
+        url = reverse("admin:accounts_useravailability_changelist")
+        user_ids = self._get_filtered_values(
+            url, {"past_session_member": "no"}, field="user_id"
+        )
+        assert self.past_djangonaut.pk not in user_ids
+        assert self.no_session_user.pk in user_ids
+
+    def test_useravailability_updated_at_filter(self) -> None:
+        url = reverse("admin:accounts_useravailability_changelist")
+        response = self.client.get(url, {"updated_at__gte": "2020-01-01"})
+        assert response.status_code == HTTPStatus.OK