Merge pull request #694 from djangonaut-space/develop

Production Release - 2026-02-18

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

home/dataclasses.py

@@ -8,6 +8,8 @@
 from dataclasses import dataclass
 from typing import Optional
 
+from django.urls import reverse
+
 from accounts.models import CustomUser
 from home.models import Project, Team, UserSurveyResponse
 
@@ -52,3 +54,13 @@ class TeamStatistics:
     navigator_meeting_hours: int
     captain_meetings: list[dict]  # Keep as dict since it comes from utils
     is_valid: bool
+
+    @property
+    def compare_availability_url(self) -> str:
+        all_members = self.navigators + ([self.captain] if self.captain else [])
+        all_members.extend([d.user for d in self.djangonaut_details])
+        user_ids = [str(u.id) for u in all_members]
+        return (
+            reverse("compare_availability")
+            + f"?users={','.join(user_ids)}&session={self.team.session_id}"
+        )

home/factories.py

@@ -20,6 +20,7 @@
     UserQuestionResponse,
     UserSurveyResponse,
     Waitlist,
+    ProjectPreference,
 )
 
 
@@ -177,3 +178,12 @@ class Meta:
     author = factory.SubFactory(UserFactory)
     session = factory.SubFactory(SessionFactory)
     is_published = False
+
+
+class ProjectPreferenceFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = ProjectPreference
+
+    user = factory.SubFactory(UserFactory)
+    session = factory.SubFactory(SessionFactory)
+    project = factory.SubFactory(ProjectFactory)

home/filters.py

@@ -33,6 +33,12 @@ class ApplicantFilterSet(django_filters.FilterSet):
         field_name="selection_rank", lookup_expr="lte", label="Maximum Selection Rank"
     )
 
+    project_preferences = django_filters.ModelChoiceFilter(
+        field_name="user__project_preferences__project",
+        queryset=Project.objects.none(),
+        label="Project Preference",
+    )
+
     team = django_filters.ModelChoiceFilter(
         field_name="user__session_memberships__team",
         queryset=Team.objects.none(),
@@ -90,6 +96,9 @@ def __init__(self, *args, session=None, **kwargs):
             self.filters["team"].queryset = team_queryset
             self.filters["overlap_with_navigators"].queryset = team_queryset
             self.filters["overlap_with_captain"].queryset = team_queryset
+            self.filters["project_preferences"].queryset = (
+                session.available_projects.all().order_by("name")
+            )
 
     def filter_by_team(
         self, queryset: QuerySet, name: str, value: Team | None