django-forms-workflows 0.74.2__tar.gz → 0.74.4__tar.gz

{django_forms_workflows-0.74.2 → django_forms_workflows-0.74.4}/CHANGELOG.md

@@ -7,6 +7,41 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.74.4] - 2026-04-29
+
+### Fixed
+- **`send_notification_rules` is now idempotent on retry.** When a Celery
+  worker dies mid-execution and the broker requeues the task (e.g. with
+  `task_acks_late=True` + `task_reject_on_worker_lost=True`), the second
+  run skips recipients already present in `NotificationLog` with
+  `status=sent`. Failed sends are still retried. Previously a worker
+  crash mid-send could either lose the notification entirely (with
+  default acks-early) or, if acks-late was enabled, double-send to the
+  recipients delivered before the crash. Investigation context: a
+  production submission silently produced zero notification emails
+  while an identical submission a minute later succeeded — most likely
+  a prefork worker process death between ack and the send call.
+
+## [0.74.3] - 2026-04-29
+
+### Fixed
+- **Notification-rule sync exports are now deterministic across
+  environments.** Two non-determinism sources let DB row order leak
+  into the export payload, producing false-positive
+  `Workflow notification rules: 6 → 6` diffs even when the underlying
+  rules were identical: rule list order relied on Meta ordering that
+  doesn't disambiguate workflow-level rules sharing an event, and
+  `notify_groups` M2M ordering relies on through-row id (varies per
+  instance). Both lists are now sorted by content, so push/pull and
+  the diff viewer give stable results.
+
+### Changed
+- **Diff viewer reports which notification rule changed when counts
+  match.** When stage- or workflow-level notification rule lists
+  differ in content but not in length, the diff now names the rule
+  (by event) and the specific keys that changed instead of showing
+  an opaque `6 → 6` message.
+
 ## [0.74.2] - 2026-04-29
 
 ### Fixed

{django_forms_workflows-0.74.2 → django_forms_workflows-0.74.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-forms-workflows
-Version: 0.74.2
+Version: 0.74.4
 Summary: Enterprise-grade, database-driven form builder with approval workflows and external data integration
 License: LGPL-3.0-only
 License-File: LICENSE

{django_forms_workflows-0.74.2 → django_forms_workflows-0.74.4}/django_forms_workflows/diff_views.py

@@ -103,6 +103,20 @@ def _build_summary(forms_data):
                     diffs.append(
                         f"Stage '{key[1]}' notifications: {len(b_notifs)} → {len(o_notifs)}"
                     )
+                elif b_notifs != o_notifs:
+                    for idx, (bn, on) in enumerate(
+                        zip(b_notifs, o_notifs, strict=False)
+                    ):
+                        if bn == on:
+                            continue
+                        changed_keys = sorted(
+                            k for k in set(bn) | set(on) if bn.get(k) != on.get(k)
+                        )
+                        label = bn.get("event") or on.get("event") or f"#{idx}"
+                        diffs.append(
+                            f"Stage '{key[1]}' notification '{label}' changed: "
+                            f"{', '.join(changed_keys)}"
+                        )
                 # Approval groups: support both old string lists and new dict lists
                 b_groups = {
                     g["name"] if isinstance(g, dict) else g
@@ -147,10 +161,29 @@ def _build_summary(forms_data):
             # Workflow-level notification rules (stage=null)
             b_wf_notifs = b_wf.get("notification_rules", [])
             o_wf_notifs = o_wf.get("notification_rules", [])
-            if b_wf_notifs != o_wf_notifs:
+            if len(b_wf_notifs) != len(o_wf_notifs):
                 diffs.append(
                     f"Workflow notification rules: {len(b_wf_notifs)} → {len(o_wf_notifs)}"
                 )
+            elif b_wf_notifs != o_wf_notifs:
+                # Same count but content differs — surface what changed.
+                changed = []
+                for idx, (br, or_) in enumerate(
+                    zip(b_wf_notifs, o_wf_notifs, strict=False)
+                ):
+                    if br == or_:
+                        continue
+                    changed_keys = sorted(
+                        k for k in set(br) | set(or_) if br.get(k) != or_.get(k)
+                    )
+                    label = br.get("event") or or_.get("event") or f"#{idx}"
+                    diffs.append(
+                        f"Workflow notification rule '{label}' changed: "
+                        f"{', '.join(changed_keys)}"
+                    )
+                    changed.append(label)
+                if not changed:
+                    diffs.append("Workflow notification rules: order changed")
 
         # Form metadata
         meta_keys = [

{django_forms_workflows-0.74.2 → django_forms_workflows-0.74.4}/django_forms_workflows/sync_api.py

@@ -22,6 +22,7 @@ Management commands (bundled)::
     python manage.py push_forms --dest-url=https://prod.example.com --token=SECRET --slugs=time-off,onboarding
 """
 
+import json
 import logging
 from decimal import Decimal
 
@@ -241,6 +242,34 @@ def _serialize_field(field, wf_pk_to_index=None):
     }
 
 
+def _serialize_notification_rule(r):
+    # Sort notify_groups so order is deterministic across environments
+    # (M2M default ordering relies on row id, which differs per-instance).
+    return {
+        "event": r.event,
+        "use_triggering_stage": r.use_triggering_stage,
+        "notify_submitter": r.notify_submitter,
+        "email_field": r.email_field,
+        "static_emails": r.static_emails,
+        "cc_email_field": r.cc_email_field,
+        "cc_static_emails": r.cc_static_emails,
+        "notify_stage_assignees": r.notify_stage_assignees,
+        "notify_stage_groups": r.notify_stage_groups,
+        "subject_template": r.subject_template,
+        "body_template": r.body_template,
+        "conditions": r.conditions,
+        "notify_groups": sorted(g.name for g in r.notify_groups.all()),
+    }
+
+
+def _sorted_rule_payloads(rules):
+    # Sort by serialized content so order is deterministic across environments.
+    # Two rules with the same event would otherwise come back from the DB in
+    # indeterminate order, producing false-positive diffs on push/pull.
+    serialized = [_serialize_notification_rule(r) for r in rules]
+    return sorted(serialized, key=lambda d: json.dumps(d, sort_keys=True, default=str))
+
+
 def _serialize_workflow_stage(stage):
     # Serialize approval groups with their sequence position so that
     # "sequence" stages are restored in the correct order on import.
@@ -265,24 +294,7 @@ def _serialize_workflow_stage(stage):
         "allow_reassign": stage.allow_reassign,
         "allow_send_back": stage.allow_send_back,
         "allow_edit_form_data": stage.allow_edit_form_data,
-        "notification_rules": [
-            {
-                "event": r.event,
-                "use_triggering_stage": r.use_triggering_stage,
-                "notify_submitter": r.notify_submitter,
-                "email_field": r.email_field,
-                "static_emails": r.static_emails,
-                "cc_email_field": r.cc_email_field,
-                "cc_static_emails": r.cc_static_emails,
-                "notify_stage_assignees": r.notify_stage_assignees,
-                "notify_stage_groups": r.notify_stage_groups,
-                "subject_template": r.subject_template,
-                "body_template": r.body_template,
-                "conditions": r.conditions,
-                "notify_groups": [g.name for g in r.notify_groups.all()],
-            }
-            for r in stage.notification_rules.all()
-        ],
+        "notification_rules": _sorted_rule_payloads(stage.notification_rules.all()),
     }
 
 
@@ -355,24 +367,9 @@ def _serialize_workflow(wf):
         # Visual editor data
         "visual_workflow_data": wf.visual_workflow_data,
         # Workflow-level notification rules (stage=null)
-        "notification_rules": [
-            {
-                "event": r.event,
-                "use_triggering_stage": r.use_triggering_stage,
-                "notify_submitter": r.notify_submitter,
-                "email_field": r.email_field,
-                "static_emails": r.static_emails,
-                "cc_email_field": r.cc_email_field,
-                "cc_static_emails": r.cc_static_emails,
-                "notify_stage_assignees": r.notify_stage_assignees,
-                "notify_stage_groups": r.notify_stage_groups,
-                "subject_template": r.subject_template,
-                "body_template": r.body_template,
-                "conditions": r.conditions,
-                "notify_groups": [g.name for g in r.notify_groups.all()],
-            }
-            for r in wf.notification_rules.filter(stage__isnull=True)
-        ],
+        "notification_rules": _sorted_rule_payloads(
+            wf.notification_rules.filter(stage__isnull=True)
+        ),
         "webhook_endpoints": [
             _serialize_webhook_endpoint(endpoint)
             for endpoint in wf.webhook_endpoints.all().order_by("name")

{django_forms_workflows-0.74.2 → django_forms_workflows-0.74.4}/django_forms_workflows/tasks.py

@@ -1358,6 +1358,18 @@ def send_notification_rules(
         event, "{form_name} (ID {submission_id})"
     )
 
+    # Idempotency guard: if this task is being re-executed (e.g. acks_late
+    # requeued it after a worker died mid-send), skip recipients we already
+    # successfully delivered to. Only "sent" entries dedup — "failed" entries
+    # should be retried.
+    already_sent: set[str] = set(
+        NotificationLog.objects.filter(
+            submission_id=submission_id,
+            notification_type=event,
+            status="sent",
+        ).values_list("recipient_email", flat=True)
+    )
+
     for rule in rules:
         # Evaluate optional conditions
         if rule.conditions:
@@ -1388,9 +1400,28 @@ def send_notification_rules(
         cc_recipients = _collect_notification_cc(rule, form_data)
         # Prevent duplicate delivery: don't CC anyone already in the TO list.
         cc_recipients = [c for c in cc_recipients if c not in recipients]
+
+        # Drop recipients already successfully delivered (acks_late retry guard).
+        # NotificationLog stores TO entries as the bare email and CC entries as
+        # ``cc:{recipient}`` — match each list against its own log key format.
+        if already_sent:
+            before_to, before_cc = len(recipients), len(cc_recipients)
+            recipients = [r for r in recipients if r not in already_sent]
+            cc_recipients = [c for c in cc_recipients if f"cc:{c}" not in already_sent]
+            skipped = (before_to - len(recipients)) + (before_cc - len(cc_recipients))
+            if skipped:
+                logger.info(
+                    "NotificationRule %s: skipped %d already-sent recipient(s) "
+                    "for submission %s (idempotency)",
+                    rule.id,
+                    skipped,
+                    submission.id,
+                )
+
         if not recipients:
             logger.info(
-                "NotificationRule %s: no recipients resolved for submission %s; skipping.",
+                "NotificationRule %s: no recipients to send to for submission %s; "
+                "skipping (resolved zero, or all already delivered).",
                 rule.id,
                 submission.id,
             )

{django_forms_workflows-0.74.2 → django_forms_workflows-0.74.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "django-forms-workflows"
-version = "0.74.2"
+version = "0.74.4"
 description = "Enterprise-grade, database-driven form builder with approval workflows and external data integration"
 license = "LGPL-3.0-only"
 readme = "README.md"