feat: add ModalSubscribeView for multi-list subscription from modal

feat: add mailing list selection modal to subscribe card

feat: wire modal context through mixin and page templates

feat: add mailing list modal checkbox styles

feat: open list-selection modal from subscribed/pending manage button

fix: use :style binding to override dialog-modal CSS display rule

fix: use :target dialog pattern instead of Alpine x-show for modal

fix: align modal UI to Figma - title, checkboxes, select all, button order

fix: checkbox colors

fix: select-all selector, email validation, and CSS token issues in modal

fix: checkbox states and dark-mode checkmark in mailing list modal

fix: override legacy checkbox specificity and cancel tailwind orange tint

fix: use svg icon + sibling pattern for modal checkbox, drop mask-image approach

fix: move inline import to module level and fix unsubscribe error handling

fix: gate modal open on valid email format

fix: remove dead loading/spinner CSS and replace margin !important with shorthand

chore: delete orphaned subscribe success card template

fix: use MailmanClient().unsubscribe in ModalSubscribeView

fix: fixes after rebase

chore: avoid redundant code

Author: herzog0

core/views.py

@@ -47,6 +47,7 @@
 
 from . import context_processors
 from .mixins import V3Mixin, iter_v3_views
+from mailing_list.constants import MAILING_LIST_LABELS as _ML_LABELS
 from mailing_list.mixins import (
     MailingListCardMixin,
     get_subscription_state_count_and_email,
@@ -2249,6 +2250,8 @@ def _intro_card(library_name, authors):
         context["demo_mailman_lists"] = constants.MAILMAN_LISTS
         context["demo_subscribe_url"] = reverse("mailing-list-subscribe")
         context["demo_quick_subscribe_url"] = reverse("mailing-list-quick-subscribe")
+        context["demo_modal_subscribe_url"] = reverse("mailing-list-modal-subscribe")
+        context["demo_mailing_lists"] = _ML_LABELS.values()
 
         mailing_list_state = None
 

mailing_list/constants.py

@@ -37,6 +37,7 @@ class MailingLists(Enum):
 
 MAILING_LIST_LABELS = {
     MailingLists.BOOST.value: {
+        "id": f"{MailingLists.BOOST.value}.{MAILMAN_DOMAIN}",
         "name": "Boost Developers",
         "address": build_mailing_list_address(MailingLists.BOOST.value),
         "description": (
@@ -48,6 +49,7 @@ class MailingLists(Enum):
         ),
     },
     MailingLists.BOOST_ANNOUNCE.value: {
+        "id": f"{MailingLists.BOOST_ANNOUNCE.value}.{MAILMAN_DOMAIN}",
         "name": "Boost Announcements",
         "address": build_mailing_list_address(MailingLists.BOOST_ANNOUNCE.value),
         "description": (
@@ -57,6 +59,7 @@ class MailingLists(Enum):
         ),
     },
     MailingLists.BOOST_USERS.value: {
+        "id": f"{MailingLists.BOOST_USERS.value}.{MAILMAN_DOMAIN}",
         "name": "Boost Users",
         "address": build_mailing_list_address(MailingLists.BOOST_USERS.value),
         "description": (
@@ -68,7 +71,7 @@ class MailingLists(Enum):
     },
 }
 
-MAILMAN_LISTS = [f"{_l}.{MAILMAN_DOMAIN}" for _l in MAILING_LIST_LABELS.keys()]
+MAILMAN_LISTS = [_l["id"] for _l in MAILING_LIST_LABELS.values()]
 
 # we only want boost devel for now, leaving the others in case that changes.
 ML_STATS_URLS = [

mailing_list/mixins.py

@@ -63,7 +63,11 @@ def get_context_data(self, **kwargs):
         context["mailing_list_card_subscribe_url"] = reverse(
             "mailing-list-quick-subscribe"
         )
+        context["mailing_list_card_modal_subscribe_url"] = reverse(
+            "mailing-list-modal-subscribe"
+        )
         context["mailing_list_card_list_id"] = _DEFAULT_LIST_ID
+        context["mailing_list_card_lists"] = constants.MAILING_LIST_LABELS.values()
 
         if request.user.is_authenticated:
             managed_lists = set(constants.MAILMAN_LISTS)
@@ -73,6 +77,11 @@ def get_context_data(self, **kwargs):
             context["mailing_list_card_subscription_count"] = state.count
             context["mailing_list_card_user_email"] = state.email
             context["mailing_list_card_manage_url"] = reverse("profile-account")
+            context["mailing_list_card_subscribed_ids"] = set(
+                UserMailingListSubscription.objects.filter(
+                    user=request.user, list_id__in=managed_lists
+                ).values_list("list_id", flat=True)
+            )
 
         # URL-param overrides for the no-JS PRG flow.
         # Error state always wins (DB record was rolled back on failure).

mailing_list/urls.py

@@ -1,6 +1,7 @@
 from django.urls import path
 
 from mailing_list.views import ConfirmSubscriptionView
+from mailing_list.views import ModalSubscribeView
 from mailing_list.views import QuickSubscribeView
 from mailing_list.views import SubscribeView
 
@@ -11,6 +12,11 @@
         QuickSubscribeView.as_view(),
         name="mailing-list-quick-subscribe",
     ),
+    path(
+        "modal-subscribe/",
+        ModalSubscribeView.as_view(),
+        name="mailing-list-modal-subscribe",
+    ),
     path(
         "confirm/<str:token>/",
         ConfirmSubscriptionView.as_view(),

mailing_list/views.py

@@ -216,6 +216,25 @@ def post(self, request):
 """
 
 
+def _build_card_context(request) -> dict:
+    """Build the base context dict for rendering _mailing_list_card.html."""
+    managed_lists = set(constants.MAILMAN_LISTS)
+    ctx = {
+        "subscribe_url": reverse("mailing-list-quick-subscribe"),
+        "modal_subscribe_url": reverse("mailing-list-modal-subscribe"),
+        "login_url": reverse("account_login"),
+        "mailing_lists": constants.MAILING_LIST_LABELS.values(),
+        "subscribed_ids": set(),
+    }
+    if request.user.is_authenticated:
+        ctx["subscribed_ids"] = set(
+            UserMailingListSubscription.objects.filter(
+                user=request.user, list_id__in=managed_lists
+            ).values_list("list_id", flat=True)
+        )
+    return ctx
+
+
 class QuickSubscribeView(View):
     """Subscribe to a single list. Works for both authenticated and anonymous users.
 
@@ -224,17 +243,10 @@ class QuickSubscribeView(View):
     """
 
     def _card(self, request, **ctx):
-        subscribe_url = reverse("mailing-list-quick-subscribe")
-        login_url = reverse("account_login")
         return render(
             request,
             "v3/includes/_mailing_list_card.html",
-            {
-                "subscribe_url": subscribe_url,
-                "login_url": login_url,
-                "list_id": constants.MAILMAN_LISTS[0],
-                **ctx,
-            },
+            {**_build_card_context(request), **ctx},
         )
 
     def post(self, request):
@@ -312,14 +324,12 @@ def _handle_authenticated(self, request, email, list_id, managed_lists):
                 user=request.user, list_id__in=managed_lists
             ).count()
             if _is_htmx(request):
-                return render(
+                return self._card(
                     request,
-                    "v3/mailing_list/_subscribe_success_card.html",
-                    {
-                        "email": existing.email,
-                        "subscription_count": subscription_count,
-                        "manage_url": manage_url,
-                    },
+                    state="active",
+                    user_email=existing.email,
+                    subscription_count=subscription_count,
+                    manage_url=manage_url,
                 )
             return _prg_redirect(request)
 
@@ -498,3 +508,152 @@ def _label(list_id):
                 "home_url": "/",
             },
         )
+
+
+class ModalSubscribeView(View):
+    """Subscribe to one or more lists via the list-selection modal.
+
+    Accepts email + one or more list_id POST values. Works for both authenticated
+    and anonymous users. Only reachable via HTMX (the modal is Alpine-only).
+
+    Authenticated flow: subscribes to newly checked lists and unsubscribes from
+    any currently tracked lists that were unchecked.
+    Anonymous flow: subscribe-only - sends a single confirmation email for all
+    checked lists. Unsubscribe not supported for anonymous users.
+    """
+
+    def _card(self, request, **ctx):
+        return render(
+            request,
+            "v3/includes/_mailing_list_card.html",
+            {**_build_card_context(request), **ctx},
+        )
+
+    def post(self, request):
+        email = request.POST.get("email", "").strip()
+        managed_lists = set(constants.MAILMAN_LISTS)
+        list_ids = [
+            lid for lid in request.POST.getlist("list_id") if lid in managed_lists
+        ]
+
+        if not email:
+            return self._card(
+                request, state="error", error_message="Email is required."
+            )
+
+        if _is_rate_limited(request):
+            return self._card(
+                request,
+                state="error",
+                error_message="Too many attempts. Please try again later.",
+                user_email=email,
+            )
+
+        if request.user.is_authenticated:
+            return self._handle_authenticated(request, email, list_ids, managed_lists)
+        return self._handle_anonymous(request, email, list_ids)
+
+    def _handle_authenticated(self, request, email, list_ids, managed_lists):
+        manage_url = reverse("profile-account")
+
+        current_subs = {
+            sub.list_id: sub
+            for sub in UserMailingListSubscription.objects.filter(
+                user=request.user, list_id__in=managed_lists
+            )
+        }
+        to_subscribe = [lid for lid in list_ids if lid not in current_subs]
+        to_unsubscribe = [lid for lid in current_subs if lid not in list_ids]
+
+        for lid in to_unsubscribe:
+            sub = current_subs[lid]
+            if sub.status == SubscriptionStatus.PENDING:
+                sub.delete()
+            else:
+                try:
+                    MailmanClient().unsubscribe(sub.email, lid)
+                    UserMailingListSubscription.objects.filter(
+                        user=request.user, list_id=lid
+                    ).delete()
+                except MailmanAPIError as exc:
+                    logger.error(
+                        "Mailman unsubscribe error for %s/%s: %s", sub.email, lid, exc
+                    )
+
+        if not to_subscribe:
+            subscription_count = UserMailingListSubscription.objects.filter(
+                user=request.user, list_id__in=managed_lists
+            ).count()
+            if subscription_count == 0:
+                return self._card(request, user_email=email)
+            return self._card(
+                request,
+                state="active",
+                user_email=email,
+                subscription_count=subscription_count,
+                manage_url=manage_url,
+            )
+
+        succeeded = []
+        for lid in to_subscribe:
+            try:
+                with transaction.atomic():
+                    UserMailingListSubscription.objects.update_or_create(
+                        user=request.user,
+                        list_id=lid,
+                        defaults={"email": email, "status": SubscriptionStatus.PENDING},
+                    )
+                succeeded.append(lid)
+            except IntegrityError:
+                pass
+
+        if not succeeded:
+            return self._card(
+                request,
+                state="error",
+                error_message="Could not subscribe. Please try again.",
+                user_email=email,
+            )
+
+        try:
+            _send_confirmation_email(request, email, request.user.pk, succeeded)
+        except Exception as exc:
+            logger.error("Failed to send confirmation email to %s: %s", email, exc)
+            UserMailingListSubscription.objects.filter(
+                user=request.user, list_id__in=succeeded
+            ).delete()
+            return self._card(
+                request,
+                state="error",
+                error_message="Could not send confirmation email. Please try again.",
+                user_email=email,
+            )
+
+        return self._card(
+            request,
+            state="pending",
+            user_email=email,
+            manage_url=manage_url,
+        )
+
+    def _handle_anonymous(self, request, email, list_ids):
+        if not list_ids:
+            return self._card(
+                request,
+                state="error",
+                error_message="Please select at least one mailing list.",
+                user_email=email,
+            )
+
+        try:
+            _send_confirmation_email(request, email, None, list_ids)
+        except Exception as exc:
+            logger.error("Failed to send confirmation email to %s: %s", email, exc)
+            return self._card(
+                request,
+                state="error",
+                error_message="Could not send confirmation email. Please try again.",
+                user_email=email,
+            )
+
+        return self._card(request, state="pending", user_email=email)