[ENG-12449][ENG-12705] Project PR: Post-ENTER-P2

admin/notifications/forms.py

@@ -65,6 +65,12 @@ class NotificationCampaignCreateForm(forms.ModelForm):
         help_text='The time in seconds between dispatches of campaign batches.',
     )
 
+    log_email_recipients = forms.CharField(
+        required=False,
+        initial='',
+        help_text='List of email addresses to receive campaign log emails, separated by commas.',
+    )
+
     class Meta:
         model = NotificationCampaign
         fields = (

admin/notifications/views.py

@@ -19,7 +19,7 @@
 from mako.parsetree import ControlLine
 from string import Formatter
 from osf.email import _render_email_html
-from osf.email.notification_campaign import FILTER_PRESETS, counter_subquery, build_campaign_filter_query
+from osf.email.notification_campaign import FILTER_PRESETS, counter_subquery, build_campaign_filter_query, get_campaign_recipient_stats
 from website import settings
 from urllib.parse import urlencode
 
@@ -392,6 +392,9 @@ def get_object(self, queryset=None):
     def get_context_data(self, *args, **kwargs):
         notification_campaign = self.get_object()
         metadata = notification_campaign.metadata or {}
+        stats = get_campaign_recipient_stats(notification_campaign.id)
+        queued = stats['queued_count']
+        awaiting = stats['awaiting_count']
 
         context = {
             'notification_campaign': notification_campaign,
@@ -403,6 +406,8 @@ def get_context_data(self, *args, **kwargs):
                 ('Status', notification_campaign.get_status_display()),
                 ('Recipients', notification_campaign.recipient_count),
                 ('Sent', notification_campaign.sent_count),
+                ('Queued', queued),
+                ('Awaiting Delivery', awaiting),
                 ('Failed', notification_campaign.failed_count),
                 ('Retries', notification_campaign.retries),
                 ('Created', notification_campaign.created_at),
@@ -437,7 +442,16 @@ def get_context_data(self, *args, **kwargs):
 
         if notification_campaign.status != NotificationCampaignStatus.CREATED:
             processed = notification_campaign.sent_count + notification_campaign.failed_count
-            pending = max(notification_campaign.recipient_count - processed, 0)
+            pending = max(
+                notification_campaign.recipient_count - processed - queued - awaiting,
+                0,
+            )
+            awaiting_delivery = (
+                notification_campaign.status == NotificationCampaignStatus.RUNNING
+                and pending == 0
+                and queued == 0
+                and awaiting > 0
+            )
 
             sent_percent = (
                 notification_campaign.sent_count / notification_campaign.recipient_count * 100
@@ -447,8 +461,19 @@ def get_context_data(self, *args, **kwargs):
                 notification_campaign.failed_count / notification_campaign.recipient_count * 100
                 if notification_campaign.recipient_count else 0
             )
+            queued_percent = (
+                queued / notification_campaign.recipient_count * 100
+                if notification_campaign.recipient_count else 0
+            )
+            awaiting_percent = (
+                awaiting / notification_campaign.recipient_count * 100
+                if notification_campaign.recipient_count else 0
+            )
 
-            pending_percent = max(100 - sent_percent - failed_percent, 0)
+            pending_percent = max(
+                100 - sent_percent - failed_percent - queued_percent - awaiting_percent,
+                0,
+            )
             elapsed = None
             speed = None
             eta = None
@@ -462,8 +487,9 @@ def get_context_data(self, *args, **kwargs):
                 elapsed_seconds = elapsed.total_seconds()
                 if processed > 0 and elapsed_seconds > 0:
                     speed = processed / elapsed_seconds
-                    if pending:
-                        eta = timedelta(seconds=int(pending / speed))
+                    remaining = pending + queued
+                    if remaining:
+                        eta = timedelta(seconds=int(remaining / speed))
                         estimated_finish = timezone.now() + eta
 
             if notification_campaign.updated_at:
@@ -476,8 +502,13 @@ def get_context_data(self, *args, **kwargs):
             context.update({
                 'processed': processed,
                 'pending': pending,
+                'queued': queued,
+                'awaiting': awaiting,
+                'awaiting_delivery': awaiting_delivery,
                 'sent_percent': sent_percent,
                 'failed_percent': failed_percent,
+                'queued_percent': queued_percent,
+                'awaiting_percent': awaiting_percent,
                 'pending_percent': pending_percent,
                 'elapsed': elapsed,
                 'speed': speed,
@@ -585,6 +616,7 @@ def form_valid(self, form):
                 'time_window': form.cleaned_data['time_window'],
                 'max_queued_batches': form.cleaned_data['max_queued_batches'],
                 'dispatch_interval': form.cleaned_data['dispatch_interval'],
+                'log_email_recipients': form.cleaned_data['log_email_recipients'],
             },
             'sendgrid_bulk': form.cleaned_data.get('sendgrid_bulk', False),
             'recipients_creation_finished': False,

admin/templates/notifications/notification_campaigns_detail.html

@@ -62,13 +62,30 @@ <h2 id="campaign_name">{{ notification_campaign.name }}</h2>
             <strong>Last activity:</strong> {{ last_activity_ago }} ago
         {% endif %}
     </div>
+    {% if awaiting_delivery %}
+    <div class="alert alert-info">
+        <strong>Awaiting delivery:</strong>
+        All recipients have been submitted to SendGrid.
+        Waiting for delivery confirmation ({{ awaiting }} awaiting).
+    </div>
+    {% endif %}
     <div class="progress">
 
         <div class="progress-bar progress-bar-success"
             style="width: {{ sent_percent }}%;">
             {{ notification_campaign.sent_count }}
         </div>
 
+        <div class="progress-bar progress-bar-info"
+            style="width: {{ awaiting_percent }}%;">
+            {{ awaiting }}
+        </div>
+
+        <div class="progress-bar progress-bar-warning"
+            style="width: {{ queued_percent }}%;">
+            {{ queued }}
+        </div>
+
         <div class="progress-bar progress-bar-danger"
             style="width: {{ failed_percent }}%;">
             {{ notification_campaign.failed_count }}
@@ -88,6 +105,16 @@ <h4>Progress</h4>
         <td>{{ processed }} / {{ notification_campaign.recipient_count }}</td>
     </tr>
 
+    <tr>
+        <th>Queued</th>
+        <td>{{ queued }}</td>
+    </tr>
+
+    <tr>
+        <th>Awaiting Delivery</th>
+        <td>{{ awaiting }}</td>
+    </tr>
+
     <tr>
         <th>Pending</th>
         <td>{{ pending }}</td>

admin/templates/notifications/notification_campaing_create.html

@@ -324,6 +324,20 @@ <h4>Execution</h4>
                             </p>
                         </td>
                     </tr>
+                    <tr>
+                        <th>Log Email Recipients</th>
+                        <td>
+                            <input
+                                class="form-control"
+                                type="text"
+                                name="log_email_recipients"
+                                value="{{ form.log_email_recipients.initial }}"
+                            >
+                            <p class="help-block">
+                                {{ form.log_email_recipients.help_text }}
+                            </p>
+                        </td>
+                    </tr>
                 </table>
             </div>
         </div>

admin_tests/notifications/test_campaigns.py

@@ -64,6 +64,7 @@ def _valid_form_data(notification_type, **overrides):
         'time_window': 8 * 60 * 60,
         'max_queued_batches': settings.MAX_QUEUED_CAMPAIGN_BATCHES,
         'dispatch_interval': settings.CAMPAIGN_DISPATCH_INTERVAL,
+        'log_email_recipients': '',
     }
     data.update(overrides)
     return data
@@ -81,6 +82,7 @@ def test_valid_form_parses_context_and_filters(self, notification_type):
         assert form.cleaned_data['activity_threshold'] == settings.DEFAULT_CAMPAIGN_ACTIVITY_THRESHOLD
         assert form.cleaned_data['time_window'] == 8 * 60 * 60
         assert form.cleaned_data['sendgrid_bulk'] is False
+        assert form.cleaned_data['log_email_recipients'] == ''
 
     def test_defaults_come_from_settings(self):
         form = NotificationCampaignCreateForm()
@@ -288,6 +290,7 @@ def test_form_valid_persists_execution_metadata(self):
             'time_window': 28800,
             'max_queued_batches': 10,
             'dispatch_interval': 60,
+            'log_email_recipients': ''
         }
         assert campaign.metadata['sendgrid_bulk'] is True
         assert campaign.metadata['filters'] == {'predefined': 'active'}

api/sendgrid/views.py

@@ -44,8 +44,10 @@ class SendGridEventWebhook(APIView):
        - Enable Signed Event Webhook; copy the verification key into
          ``SENDGRID_EVENT_WEBHOOK_PUBLIC_KEY`` (``website/settings/local.py``).
        - Subscribe at least to ``delivered``, ``bounce``, and ``dropped``.
+         (``deferred`` is safe to enable but ignored for campaigns - SendGrid
+         retries those itself.)
     4. Send a notification campaign email (personalization ``custom_args`` must
-       include ``campaign_id``, ``campaign_recipient_id``, and ``run_id``).
+       include ``campaign_id``, ``campaign_recipient_id``, and ``sent_at``).
        SendGrid's "Test Your Integration" payload lacks those keys, so this view
        accepts it with 200 but does not update campaign recipients.
     """

notifications.yaml

@@ -828,3 +828,10 @@ notification_types:
     object_content_type_model_name: osfuser
     template: 'website/templates/blank.html.mako'
     tests: []
+
+  - name: notification_campaign_log
+    subject: 'Notification campaign "{campaign_name}" — {status}'
+    __docs__: ...
+    object_content_type_model_name: osfuser
+    template: 'website/templates/notification_campaign_log.html.mako'
+    tests: []

osf/email/notification_campaign/__init__.py

@@ -0,0 +1,55 @@
+from .base import NotificationCampaignTask
+from .execution import (
+    dispatch_campaign,
+    process_campaign_retry,
+    send_campaign_batch,
+    start_notification_campaign,
+)
+from .recipients import (
+    BULK_CREATE_SIZE,
+    FILTER_PRESETS,
+    assign_batch_id_to_recipients,
+    build_campaign_filter_query,
+    build_query,
+    counter_subquery,
+    create_campaign_recipients,
+    first_email_subquery,
+    get_campaign_recipient_stats,
+)
+from .webhook import (
+    CAMPAIGN_CUSTOM_ARG_KEYS,
+    SENDGRID_HARD_BOUNCE_TYPE,
+    SENDGRID_SKIP_EVENTS,
+    SENDGRID_SOFT_BOUNCE_TYPE,
+    SENDGRID_SUCCESS_EVENTS,
+    _classify_sendgrid_events,
+    _classify_sendgrid_failure,
+    _sendgrid_event_error_message,
+    process_sendgrid_campaign_events,
+)
+
+__all__ = [
+    'BULK_CREATE_SIZE',
+    'CAMPAIGN_CUSTOM_ARG_KEYS',
+    'FILTER_PRESETS',
+    'SENDGRID_HARD_BOUNCE_TYPE',
+    'SENDGRID_SKIP_EVENTS',
+    'SENDGRID_SOFT_BOUNCE_TYPE',
+    'SENDGRID_SUCCESS_EVENTS',
+    'NotificationCampaignTask',
+    '_classify_sendgrid_events',
+    '_classify_sendgrid_failure',
+    '_sendgrid_event_error_message',
+    'assign_batch_id_to_recipients',
+    'build_campaign_filter_query',
+    'build_query',
+    'counter_subquery',
+    'create_campaign_recipients',
+    'dispatch_campaign',
+    'first_email_subquery',
+    'get_campaign_recipient_stats',
+    'process_campaign_retry',
+    'process_sendgrid_campaign_events',
+    'send_campaign_batch',
+    'start_notification_campaign',
+]

osf/email/notification_campaign/base.py

@@ -0,0 +1,70 @@
+import logging
+
+from django.utils import timezone
+
+from framework import sentry
+from framework.celery_tasks import app as celery_app
+from osf.email import send_email
+from osf.models import NotificationTypeEnum
+from osf.models.notification_campaign import (
+    NotificationCampaign,
+    NotificationCampaignStatus,
+)
+
+from .recipients import get_campaign_recipient_stats
+
+logger = logging.getLogger(__name__)
+
+
+class NotificationCampaignTask(celery_app.Task):
+    """Shared guards for notification campaign Celery tasks."""
+
+    abstract = True
+
+    def get_campaign(self, campaign_id, run_id=None, *, abort_if_cancelled=True):
+        """Load a campaign, or return None if the task should no-op.
+        """
+        campaign = NotificationCampaign.objects.get(id=campaign_id)
+        if run_id is not None and campaign.run_id != run_id:
+            return None
+        if abort_if_cancelled and campaign.status == NotificationCampaignStatus.CANCELLED:
+            logger.warning(f"Campaign {campaign_id} was cancelled")
+            return None
+        return campaign
+
+    def sync_campaign_stats(self, campaign, *, save=True):
+        stats = get_campaign_recipient_stats(campaign.id)
+        campaign.recipient_count = stats['recipient_count']
+        campaign.sent_count = stats['sent_count']
+        campaign.failed_count = stats['failed_count']
+        if save:
+            campaign.save(update_fields=[
+                'recipient_count',
+                'sent_count',
+                'failed_count',
+                'updated_at',
+            ])
+        return stats
+
+    def finish_campaign(self, campaign, status=None):
+        """Sync recipient counters, set completed_at once, optionally update status, and save."""
+        self.sync_campaign_stats(campaign, save=False)
+        if campaign.completed_at is None:
+            campaign.completed_at = timezone.now()
+        if status is not None:
+            campaign.status = status
+        campaign.save()
+        self.send_campaign_log_email(campaign, status or campaign.status, f"Campaign finished with status {status or campaign.status}")
+
+    def send_campaign_log_email(self, campaign, status, message):
+        """Send a notification campaign status email."""
+        recipients = [recipient.strip() for recipient in campaign.metadata['execution'].get('log_email_recipients', '').split(',') if recipient]
+        for recipient in recipients:
+            try:
+                send_email(
+                    recipient_address=recipient,
+                    notification_type=NotificationTypeEnum.NOTIFICATION_CAMPAIGN_LOG.instance,
+                    event_context={'campaign_name': campaign.name, 'status': status, 'message': message},)
+            except Exception as exc:
+                logger.error(f"Failed to send error logs email for campaign {campaign.id}: {exc}")
+                sentry.log_message(f"Failed to send error logs email for campaign {campaign.id}: {exc}")