Send email for CF close

JelteF · JelteF · commit ddfe04dc3e48 · 2026-01-05T09:12:20.000+01:00
diff --git a/pgcommitfest/commitfest/models.py b/pgcommitfest/commitfest/models.py
@@ -6,6 +6,7 @@
 
 from datetime import datetime, timedelta, timezone
 
+from pgcommitfest.mailqueue.util import send_template_mail
 from pgcommitfest.userprofile.models import UserProfile
 
 from .util import DiffableModel
@@ -109,6 +110,75 @@ def to_json(self):
             "enddate": self.enddate.isoformat(),
         }
 
+    def send_closure_notifications(self):
+        """Send email notifications to authors of open patches when this commitfest is closed."""
+
+        # Get all patches with open status in this commitfest
+        open_patches = (
+            self.patchoncommitfest_set.filter(
+                status__in=[
+                    PatchOnCommitFest.STATUS_REVIEW,
+                    PatchOnCommitFest.STATUS_AUTHOR,
+                    PatchOnCommitFest.STATUS_COMMITTER,
+                ]
+            )
+            .select_related("patch")
+            .prefetch_related("patch__authors")
+        )
+
+        # Collect unique authors across all open patches
+        authors_to_notify = set()
+        for poc in open_patches:
+            for author in poc.patch.authors.all():
+                if author.email:
+                    authors_to_notify.add(author)
+
+        # Get the next open commitfest if available
+        next_cf = (
+            CommitFest.objects.filter(
+                status=CommitFest.STATUS_OPEN,
+                draft=False,
+                startdate__gt=self.enddate,
+            )
+            .order_by("startdate")
+            .first()
+        )
+
+        if next_cf:
+            next_cf_url = f"https://commitfest.postgresql.org/{next_cf.id}/"
+        else:
+            next_cf_url = "https://commitfest.postgresql.org/"
+
+        # Send email to each author
+        for author in authors_to_notify:
+            # Get user's notification email preference
+            email = author.email
+            try:
+                if author.userprofile and author.userprofile.notifyemail:
+                    email = author.userprofile.notifyemail.email
+            except UserProfile.DoesNotExist:
+                pass
+
+            # Get user's open patches in this commitfest
+            user_patches = [
+                poc for poc in open_patches if author in poc.patch.authors.all()
+            ]
+
+            send_template_mail(
+                settings.NOTIFICATION_FROM,
+                None,
+                email,
+                f"Commitfest {self.name} has closed",
+                "mail/commitfest_closure.txt",
+                {
+                    "user": author,
+                    "commitfest": self,
+                    "patches": user_patches,
+                    "next_cf": next_cf,
+                    "next_cf_url": next_cf_url,
+                },
+            )
+
     @staticmethod
     def _are_relevant_commitfests_up_to_date(cfs, current_date):
         inprogress_cf = cfs["in_progress"]
@@ -143,15 +213,18 @@ def _refresh_relevant_commitfests(cls, for_update):
             if inprogress_cf and inprogress_cf.enddate < current_date:
                 inprogress_cf.status = CommitFest.STATUS_CLOSED
                 inprogress_cf.save()
+                inprogress_cf.send_closure_notifications()
 
             open_cf = cfs["open"]
 
             if open_cf.startdate <= current_date:
                 if open_cf.enddate < current_date:
                     open_cf.status = CommitFest.STATUS_CLOSED
+                    open_cf.save()
+                    open_cf.send_closure_notifications()
                 else:
                     open_cf.status = CommitFest.STATUS_INPROGRESS
-                open_cf.save()
+                    open_cf.save()
 
                 cls.next_open_cf(current_date).save()
 
@@ -162,6 +235,7 @@ def _refresh_relevant_commitfests(cls, for_update):
                 # If the draft commitfest has started, we need to update it
                 draft_cf.status = CommitFest.STATUS_CLOSED
                 draft_cf.save()
+                draft_cf.send_closure_notifications()
                 cls.next_draft_cf(current_date).save()
 
             return cls.relevant_commitfests(for_update=for_update)
diff --git a/pgcommitfest/commitfest/templates/mail/commitfest_closure.txt b/pgcommitfest/commitfest/templates/mail/commitfest_closure.txt
@@ -0,0 +1,21 @@
+Hello {{user.first_name|default:user.username}},
+
+Commitfest {{commitfest.name}} has now closed. You have {{patches|length}} open patch{{patches|length|pluralize:"es"}} in this commitfest:
+
+{%for poc in patches%}
+  - {{poc.patch.name}}
+    https://commitfest.postgresql.org/{{commitfest.id}}/{{poc.patch.id}}/
+{%endfor%}
+
+Please take action on {{patches|length|pluralize:"this patch,these patches"}}:
+
+1. If you want to continue working on {{patches|length|pluralize:"it,them"}}, move {{patches|length|pluralize:"it,them"}} to the next commitfest{% if next_cf %}: {{next_cf_url}}{% endif %}
+
+2. If you no longer wish to pursue {{patches|length|pluralize:"this patch,these patches"}}, please close {{patches|length|pluralize:"it,them"}} with an appropriate status (Withdrawn, Returned with feedback, etc.)
+
+{% if next_cf %}The next commitfest is {{next_cf.name}}, which runs from {{next_cf.startdate}} to {{next_cf.enddate}}.{% else %}Please check https://commitfest.postgresql.org/ for upcoming commitfests.{% endif %}
+
+Thank you for your contributions to PostgreSQL!
+
+--
+This is an automated message from the PostgreSQL Commitfest application.
diff --git a/pgcommitfest/commitfest/tests/test_closure_notifications.py b/pgcommitfest/commitfest/tests/test_closure_notifications.py
@@ -0,0 +1,196 @@
+import base64
+from datetime import datetime
+from email import message_from_string
+
+import pytest
+
+from pgcommitfest.commitfest.models import Patch, PatchOnCommitFest, Topic
+from pgcommitfest.mailqueue.models import QueuedMail
+
+pytestmark = pytest.mark.django_db
+
+
+def get_email_body(queued_mail):
+    """Extract and decode the email body from a QueuedMail object."""
+    msg = message_from_string(queued_mail.fullmsg)
+    for part in msg.walk():
+        if part.get_content_type() == "text/plain":
+            payload = part.get_payload()
+            return base64.b64decode(payload).decode("utf-8")
+    return ""
+
+
+@pytest.fixture
+def topic():
+    """Create a test topic."""
+    return Topic.objects.create(topic="General")
+
+
+def test_send_closure_notifications_to_authors_of_open_patches(
+    alice, in_progress_cf, topic
+):
+    """Authors of patches with open status should receive closure notifications."""
+    patch = Patch.objects.create(name="Test Patch", topic=topic)
+    patch.authors.add(alice)
+    PatchOnCommitFest.objects.create(
+        patch=patch,
+        commitfest=in_progress_cf,
+        enterdate=datetime.now(),
+        status=PatchOnCommitFest.STATUS_REVIEW,
+    )
+
+    in_progress_cf.send_closure_notifications()
+
+    assert QueuedMail.objects.count() == 1
+    mail = QueuedMail.objects.first()
+    assert mail.receiver == alice.email
+    assert f"Commitfest {in_progress_cf.name} has closed" in mail.fullmsg
+    body = get_email_body(mail)
+    assert "Test Patch" in body
+
+
+def test_no_notification_for_committed_patches(alice, in_progress_cf, topic):
+    """Authors of committed patches should not receive notifications."""
+    patch = Patch.objects.create(name="Committed Patch", topic=topic)
+    patch.authors.add(alice)
+    PatchOnCommitFest.objects.create(
+        patch=patch,
+        commitfest=in_progress_cf,
+        enterdate=datetime.now(),
+        leavedate=datetime.now(),
+        status=PatchOnCommitFest.STATUS_COMMITTED,
+    )
+
+    in_progress_cf.send_closure_notifications()
+
+    assert QueuedMail.objects.count() == 0
+
+
+def test_no_notification_for_withdrawn_patches(alice, in_progress_cf, topic):
+    """Authors of withdrawn patches should not receive notifications."""
+    patch = Patch.objects.create(name="Withdrawn Patch", topic=topic)
+    patch.authors.add(alice)
+    PatchOnCommitFest.objects.create(
+        patch=patch,
+        commitfest=in_progress_cf,
+        enterdate=datetime.now(),
+        leavedate=datetime.now(),
+        status=PatchOnCommitFest.STATUS_WITHDRAWN,
+    )
+
+    in_progress_cf.send_closure_notifications()
+
+    assert QueuedMail.objects.count() == 0
+
+
+def test_one_email_per_author_with_multiple_patches(alice, in_progress_cf, topic):
+    """An author with multiple open patches should receive one email listing all patches."""
+    patch1 = Patch.objects.create(name="Patch One", topic=topic)
+    patch1.authors.add(alice)
+    PatchOnCommitFest.objects.create(
+        patch=patch1,
+        commitfest=in_progress_cf,
+        enterdate=datetime.now(),
+        status=PatchOnCommitFest.STATUS_REVIEW,
+    )
+
+    patch2 = Patch.objects.create(name="Patch Two", topic=topic)
+    patch2.authors.add(alice)
+    PatchOnCommitFest.objects.create(
+        patch=patch2,
+        commitfest=in_progress_cf,
+        enterdate=datetime.now(),
+        status=PatchOnCommitFest.STATUS_AUTHOR,
+    )
+
+    in_progress_cf.send_closure_notifications()
+
+    assert QueuedMail.objects.count() == 1
+    mail = QueuedMail.objects.first()
+    body = get_email_body(mail)
+    assert "Patch One" in body
+    assert "Patch Two" in body
+
+
+def test_multiple_authors_receive_separate_emails(alice, bob, in_progress_cf, topic):
+    """Each author of open patches should receive their own notification."""
+    patch1 = Patch.objects.create(name="Alice Patch", topic=topic)
+    patch1.authors.add(alice)
+    PatchOnCommitFest.objects.create(
+        patch=patch1,
+        commitfest=in_progress_cf,
+        enterdate=datetime.now(),
+        status=PatchOnCommitFest.STATUS_REVIEW,
+    )
+
+    patch2 = Patch.objects.create(name="Bob Patch", topic=topic)
+    patch2.authors.add(bob)
+    PatchOnCommitFest.objects.create(
+        patch=patch2,
+        commitfest=in_progress_cf,
+        enterdate=datetime.now(),
+        status=PatchOnCommitFest.STATUS_COMMITTER,
+    )
+
+    in_progress_cf.send_closure_notifications()
+
+    assert QueuedMail.objects.count() == 2
+    receivers = set(QueuedMail.objects.values_list("receiver", flat=True))
+    assert receivers == {alice.email, bob.email}
+
+
+def test_notification_includes_next_commitfest_info(alice, in_progress_cf, open_cf, topic):
+    """Notification should include information about the next open commitfest."""
+    patch = Patch.objects.create(name="Test Patch", topic=topic)
+    patch.authors.add(alice)
+    PatchOnCommitFest.objects.create(
+        patch=patch,
+        commitfest=in_progress_cf,
+        enterdate=datetime.now(),
+        status=PatchOnCommitFest.STATUS_REVIEW,
+    )
+
+    in_progress_cf.send_closure_notifications()
+
+    mail = QueuedMail.objects.first()
+    body = get_email_body(mail)
+    assert open_cf.name in body
+    assert f"https://commitfest.postgresql.org/{open_cf.id}/" in body
+
+
+def test_coauthors_both_receive_notification(alice, bob, in_progress_cf, topic):
+    """Both co-authors of a patch should receive notifications."""
+    patch = Patch.objects.create(name="Coauthored Patch", topic=topic)
+    patch.authors.add(alice)
+    patch.authors.add(bob)
+    PatchOnCommitFest.objects.create(
+        patch=patch,
+        commitfest=in_progress_cf,
+        enterdate=datetime.now(),
+        status=PatchOnCommitFest.STATUS_REVIEW,
+    )
+
+    in_progress_cf.send_closure_notifications()
+
+    assert QueuedMail.objects.count() == 2
+    receivers = set(QueuedMail.objects.values_list("receiver", flat=True))
+    assert receivers == {alice.email, bob.email}
+
+
+def test_no_notification_for_author_without_email(bob, in_progress_cf, topic):
+    """Authors without email addresses should be skipped."""
+    bob.email = ""
+    bob.save()
+
+    patch = Patch.objects.create(name="Test Patch", topic=topic)
+    patch.authors.add(bob)
+    PatchOnCommitFest.objects.create(
+        patch=patch,
+        commitfest=in_progress_cf,
+        enterdate=datetime.now(),
+        status=PatchOnCommitFest.STATUS_REVIEW,
+    )
+
+    in_progress_cf.send_closure_notifications()
+
+    assert QueuedMail.objects.count() == 0
