westfarn
d830f07757
Fix campaign stuck on sending under async queue, and stop UUID ValidationError when SMTP2GO tests send "Headers Unavailable".
603 lines
20 KiB
Python
603 lines
20 KiB
Python
import hashlib
|
|
import hmac
|
|
import logging
|
|
|
|
from django.conf import settings
|
|
from django.contrib import messages
|
|
from django.contrib.auth.decorators import login_required
|
|
from django.core.exceptions import ValidationError
|
|
from django.core.validators import validate_email
|
|
from django.http import HttpResponseForbidden, JsonResponse
|
|
from django.shortcuts import get_object_or_404, redirect, render
|
|
from django.urls import reverse
|
|
from django.views.decorators.csrf import csrf_exempt
|
|
from django.views.decorators.http import require_GET, require_http_methods, require_POST
|
|
|
|
from contacts.models import Channel
|
|
from messaging.models import Campaign, MessageTemplate, ProviderEvent
|
|
from messaging.providers.postcard.pcm import (
|
|
PCM_SIZE_CHOICES,
|
|
PcmApiError,
|
|
create_custom_design,
|
|
get_design_embed_url,
|
|
list_designs,
|
|
)
|
|
from messaging.services import (
|
|
create_campaign_draft,
|
|
enqueue_campaign_send,
|
|
opted_in_contacts,
|
|
parse_scheduled_for,
|
|
record_sms_stop,
|
|
send_campaign_test_email,
|
|
)
|
|
from messaging.webhooks import (
|
|
campaign_engagement_stats,
|
|
is_inbound_sms_stop,
|
|
parse_webhook_payload,
|
|
process_pcm_postcard_webhook,
|
|
process_smtp2go_email_webhook,
|
|
process_smtp2go_sms_webhook,
|
|
)
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
def _audience_choices() -> list[tuple[str, str]]:
|
|
"""Labeled audience options with live opted-in counts."""
|
|
rows = [
|
|
(Campaign.Audience.EMAIL_OPT_IN, Channel.EMAIL, "email"),
|
|
(Campaign.Audience.SMS_OPT_IN, Channel.SMS, "SMS"),
|
|
(Campaign.Audience.POSTCARD_OPT_IN, Channel.POSTCARD, "postcard"),
|
|
]
|
|
choices = []
|
|
for value, channel, label in rows:
|
|
count = opted_in_contacts(channel).count()
|
|
noun = "contact" if count == 1 else "contacts"
|
|
choices.append(
|
|
(value, f"Mailing list · {label} opt-in ({count} {noun})")
|
|
)
|
|
return choices
|
|
|
|
|
|
def _postcard_templates():
|
|
return MessageTemplate.objects.filter(channel=Channel.POSTCARD).order_by(
|
|
"-updated_at"
|
|
)[:50]
|
|
|
|
|
|
def _campaign_report(campaign: Campaign) -> dict:
|
|
messages_qs = list(campaign.messages.select_related("contact").all()[:200])
|
|
stats = campaign_engagement_stats(campaign)
|
|
recent_events = (
|
|
ProviderEvent.objects.filter(message__campaign=campaign)
|
|
.select_related("message", "message__contact")
|
|
.order_by("-created_at")[:25]
|
|
)
|
|
return {
|
|
"messages": messages_qs,
|
|
"stats": stats,
|
|
"recent_events": recent_events,
|
|
}
|
|
|
|
|
|
def _webhook_authorized(request, *, secret: str = "", secrets: list[str] | None = None) -> bool:
|
|
"""Accept Bearer / ?token= matching any configured secret (constant-time)."""
|
|
candidates: list[str] = []
|
|
if secrets:
|
|
candidates.extend(s.strip() for s in secrets if (s or "").strip())
|
|
single = (secret or "").strip()
|
|
if single and single not in candidates:
|
|
candidates.append(single)
|
|
if not candidates:
|
|
return True
|
|
|
|
token = (request.GET.get("token") or "").strip()
|
|
auth = (request.headers.get("Authorization") or "").strip()
|
|
bearer = auth[7:].strip() if auth.lower().startswith("bearer ") else ""
|
|
# Common signature-header names PCM / gateways may use (raw secret or HMAC).
|
|
sig_headers = (
|
|
request.headers.get("X-PCM-Signature")
|
|
or request.headers.get("X-Webhook-Signature")
|
|
or request.headers.get("X-Signature")
|
|
or request.headers.get("X-Hub-Signature-256")
|
|
or ""
|
|
).strip()
|
|
if sig_headers.lower().startswith("sha256="):
|
|
sig_headers = sig_headers[7:].strip()
|
|
|
|
body = request.body or b""
|
|
for candidate in candidates:
|
|
if token and hmac.compare_digest(token, candidate):
|
|
return True
|
|
if bearer and hmac.compare_digest(bearer, candidate):
|
|
return True
|
|
if sig_headers:
|
|
if hmac.compare_digest(sig_headers, candidate):
|
|
return True
|
|
digest = hmac.new(
|
|
candidate.encode("utf-8"), body, hashlib.sha256
|
|
).hexdigest()
|
|
if hmac.compare_digest(sig_headers, digest):
|
|
return True
|
|
return False
|
|
|
|
|
|
def _pcm_webhook_secrets() -> list[str]:
|
|
"""All PCM subscription signature secrets from env."""
|
|
raw_list = (getattr(settings, "PCM_WEBHOOK_SECRETS", None) or "").strip()
|
|
single = (getattr(settings, "PCM_WEBHOOK_SECRET", None) or "").strip()
|
|
out: list[str] = []
|
|
if raw_list:
|
|
out.extend(p.strip() for p in raw_list.split(",") if p.strip())
|
|
if single and single not in out:
|
|
out.append(single)
|
|
return out
|
|
|
|
|
|
@login_required
|
|
@require_http_methods(["GET", "POST"])
|
|
def campaign_list(request):
|
|
form_errors: list[str] = []
|
|
form_data = {
|
|
"name": "",
|
|
"subject": "",
|
|
"body": "",
|
|
"audience": Campaign.Audience.EMAIL_OPT_IN,
|
|
"scheduled_for": "",
|
|
"template_id": "",
|
|
}
|
|
|
|
if request.method == "POST":
|
|
name = (request.POST.get("name") or "").strip()
|
|
subject = (request.POST.get("subject") or "").strip()
|
|
body = (request.POST.get("body") or "").strip()
|
|
audience = (request.POST.get("audience") or "").strip()
|
|
scheduled_raw = request.POST.get("scheduled_for") or ""
|
|
template_id = (request.POST.get("template_id") or "").strip()
|
|
|
|
form_data.update(
|
|
{
|
|
"name": name,
|
|
"subject": subject,
|
|
"body": body,
|
|
"audience": audience,
|
|
"scheduled_for": scheduled_raw,
|
|
"template_id": template_id,
|
|
}
|
|
)
|
|
|
|
template = None
|
|
if template_id:
|
|
template = MessageTemplate.objects.filter(pk=template_id).first()
|
|
|
|
if not name:
|
|
form_errors.append("Campaign name is required.")
|
|
if audience not in Campaign.Audience.values:
|
|
form_errors.append("Choose a recipient list.")
|
|
if audience == Campaign.Audience.POSTCARD_OPT_IN:
|
|
if not template or template.channel != Channel.POSTCARD:
|
|
form_errors.append(
|
|
"Choose a saved postcard template (design it under Postcard first)."
|
|
)
|
|
if not body:
|
|
body = "Postcard mailing"
|
|
else:
|
|
if not body:
|
|
form_errors.append("Body is required.")
|
|
if (
|
|
audience == Campaign.Audience.EMAIL_OPT_IN
|
|
and not subject
|
|
):
|
|
form_errors.append("Subject is required for email campaigns.")
|
|
|
|
scheduled_for = None
|
|
try:
|
|
scheduled_for = parse_scheduled_for(scheduled_raw)
|
|
except ValueError as exc:
|
|
form_errors.append(str(exc))
|
|
|
|
if not form_errors:
|
|
campaign = create_campaign_draft(
|
|
name=name,
|
|
audience=audience,
|
|
subject=subject,
|
|
body=body,
|
|
scheduled_for=scheduled_for,
|
|
created_by=request.user,
|
|
template=template,
|
|
)
|
|
recipient_count = campaign.messages.count()
|
|
messages.success(
|
|
request,
|
|
f'Draft “{campaign.name}” saved '
|
|
f"({recipient_count} recipient"
|
|
f"{'' if recipient_count == 1 else 's'}).",
|
|
)
|
|
return redirect("messaging:campaign_detail", pk=campaign.pk)
|
|
|
|
campaigns = Campaign.objects.all()[:100]
|
|
return render(
|
|
request,
|
|
"messaging/campaign_list.html",
|
|
{
|
|
"campaigns": campaigns,
|
|
"audience_choices": _audience_choices(),
|
|
"postcard_templates": _postcard_templates(),
|
|
"form_data": form_data,
|
|
"form_errors": form_errors,
|
|
},
|
|
)
|
|
|
|
|
|
@login_required
|
|
def campaign_detail(request, pk):
|
|
campaign = get_object_or_404(Campaign, pk=pk)
|
|
ctx = _campaign_report(campaign)
|
|
return render(
|
|
request,
|
|
"messaging/campaign_detail.html",
|
|
{
|
|
"campaign": campaign,
|
|
"messages": ctx["messages"],
|
|
"stats": ctx["stats"],
|
|
"recent_events": ctx["recent_events"],
|
|
"can_send": campaign.status
|
|
in {
|
|
Campaign.Status.DRAFT,
|
|
Campaign.Status.SCHEDULED,
|
|
Campaign.Status.SENDING,
|
|
}
|
|
and campaign.messages.exclude(
|
|
status__in={"sent", "delivered", "suppressed"}
|
|
).exists(),
|
|
},
|
|
)
|
|
|
|
|
|
@login_required
|
|
@require_GET
|
|
def campaign_status_json(request, pk):
|
|
"""JSON snapshot for live-updating the campaign report page."""
|
|
campaign = get_object_or_404(Campaign, pk=pk)
|
|
# Async queue may finish after enqueue; re-evaluate completion on poll.
|
|
from messaging.services import refresh_campaign_status
|
|
|
|
refresh_campaign_status(campaign)
|
|
campaign.refresh_from_db()
|
|
ctx = _campaign_report(campaign)
|
|
return JsonResponse(
|
|
{
|
|
"status": campaign.status,
|
|
"status_display": campaign.get_status_display(),
|
|
"stats": ctx["stats"],
|
|
"messages": [
|
|
{
|
|
"id": str(m.pk),
|
|
"contact": str(m.contact),
|
|
"status": m.status,
|
|
"status_display": m.get_status_display(),
|
|
"provider_message_id": m.provider_message_id or "",
|
|
"error": (m.error or "")[:120],
|
|
}
|
|
for m in ctx["messages"]
|
|
],
|
|
"events": [
|
|
{
|
|
"event_type": e.event_type,
|
|
"contact": str(e.message.contact) if e.message_id else "—",
|
|
"created_at": e.created_at.isoformat(),
|
|
}
|
|
for e in ctx["recent_events"]
|
|
],
|
|
}
|
|
)
|
|
|
|
|
|
@login_required
|
|
@require_POST
|
|
def campaign_send(request, pk):
|
|
campaign = get_object_or_404(Campaign, pk=pk)
|
|
if campaign.status == Campaign.Status.CANCELLED:
|
|
messages.error(request, "Cancelled campaigns cannot be sent.")
|
|
return redirect("messaging:campaign_detail", pk=campaign.pk)
|
|
|
|
count = enqueue_campaign_send(campaign)
|
|
campaign.refresh_from_db()
|
|
if count == 0:
|
|
messages.warning(request, "No draft/scheduled/failed messages to send.")
|
|
else:
|
|
sent = campaign.messages.filter(status="sent").count()
|
|
failed = campaign.messages.filter(status="failed").count()
|
|
messages.success(
|
|
request,
|
|
f"Send finished for {count} message(s): {sent} sent, {failed} failed.",
|
|
)
|
|
return redirect("messaging:campaign_detail", pk=campaign.pk)
|
|
|
|
|
|
@login_required
|
|
@require_POST
|
|
def campaign_test_send(request, pk):
|
|
campaign = get_object_or_404(Campaign, pk=pk)
|
|
to_email = (request.POST.get("test_email") or "").strip()
|
|
if not to_email:
|
|
messages.error(request, "Enter an email address for the test send.")
|
|
return redirect("messaging:campaign_detail", pk=campaign.pk)
|
|
try:
|
|
validate_email(to_email)
|
|
except ValidationError:
|
|
messages.error(request, "That test email address is not valid.")
|
|
return redirect("messaging:campaign_detail", pk=campaign.pk)
|
|
|
|
try:
|
|
send_campaign_test_email(campaign, to_email)
|
|
except ValueError as exc:
|
|
messages.error(request, str(exc))
|
|
except Exception as exc: # noqa: BLE001 — surface SMTP misconfig to portal
|
|
messages.error(request, f"Test send failed: {exc}")
|
|
else:
|
|
messages.success(request, f"Test email sent to {to_email}.")
|
|
return redirect("messaging:campaign_detail", pk=campaign.pk)
|
|
|
|
|
|
@login_required
|
|
def postcard_designer(request):
|
|
"""PCM Integrations designer — list designs + embed iframe."""
|
|
api_error = ""
|
|
designs: list[dict] = []
|
|
embed_url = ""
|
|
active_design_id = (request.GET.get("design_id") or "").strip()
|
|
active_name = ""
|
|
active_size = "46"
|
|
|
|
try:
|
|
remote = list_designs(product_type="postcard")
|
|
for item in remote:
|
|
if not isinstance(item, dict):
|
|
continue
|
|
did = item.get("designID") or item.get("design_id") or item.get("id")
|
|
if did is None:
|
|
continue
|
|
size_info = item.get("size") or {}
|
|
size_key = (
|
|
size_info.get("key")
|
|
if isinstance(size_info, dict)
|
|
else size_info
|
|
) or ""
|
|
designs.append(
|
|
{
|
|
"design_id": str(did),
|
|
"name": item.get("friendlyName")
|
|
or item.get("name")
|
|
or f"Design {did}",
|
|
"size": str(size_key),
|
|
}
|
|
)
|
|
except PcmApiError as exc:
|
|
api_error = str(exc)
|
|
|
|
# Merge saved local templates that may not appear in the remote page yet.
|
|
seen = {d["design_id"] for d in designs}
|
|
for tmpl in _postcard_templates():
|
|
front = tmpl.postcard_front or {}
|
|
did = front.get("design_id")
|
|
if did is None:
|
|
continue
|
|
did_s = str(did)
|
|
if did_s in seen:
|
|
continue
|
|
designs.insert(
|
|
0,
|
|
{
|
|
"design_id": did_s,
|
|
"name": tmpl.name,
|
|
"size": str(front.get("size") or ""),
|
|
},
|
|
)
|
|
seen.add(did_s)
|
|
|
|
if active_design_id:
|
|
match = next(
|
|
(d for d in designs if d["design_id"] == active_design_id), None
|
|
)
|
|
if match:
|
|
active_name = match["name"]
|
|
active_size = match.get("size") or "46"
|
|
else:
|
|
active_name = f"Design {active_design_id}"
|
|
try:
|
|
embed_url = get_design_embed_url(active_design_id)
|
|
except PcmApiError as exc:
|
|
api_error = api_error or str(exc)
|
|
|
|
return render(
|
|
request,
|
|
"messaging/postcard_designer.html",
|
|
{
|
|
"api_error": api_error,
|
|
"designs": designs,
|
|
"embed_url": embed_url,
|
|
"active_design_id": active_design_id,
|
|
"active_name": active_name,
|
|
"active_size": active_size,
|
|
"size_choices": PCM_SIZE_CHOICES,
|
|
"new_name": "",
|
|
"new_size": "46",
|
|
"saved_templates": _postcard_templates(),
|
|
},
|
|
)
|
|
|
|
|
|
@login_required
|
|
@require_POST
|
|
def postcard_design_create(request):
|
|
name = (request.POST.get("name") or "").strip() or "Untitled postcard"
|
|
size = (request.POST.get("size") or "46").strip()
|
|
allowed = {code for code, _ in PCM_SIZE_CHOICES}
|
|
if size not in allowed:
|
|
messages.error(request, "Invalid postcard size.")
|
|
return redirect("messaging:postcard_designer")
|
|
try:
|
|
data = create_custom_design(name=name, size=size)
|
|
except PcmApiError as exc:
|
|
messages.error(request, f"PCM create failed: {exc}")
|
|
return redirect("messaging:postcard_designer")
|
|
|
|
design_id = data.get("designID") or data.get("design_id")
|
|
if design_id is None:
|
|
messages.error(request, "PCM did not return a design ID.")
|
|
return redirect("messaging:postcard_designer")
|
|
messages.success(request, f"Design {design_id} created — edit below.")
|
|
return redirect(
|
|
f"{reverse('messaging:postcard_designer')}?design_id={design_id}"
|
|
)
|
|
|
|
|
|
@login_required
|
|
@require_POST
|
|
def postcard_design_save(request):
|
|
design_id = (request.POST.get("design_id") or "").strip()
|
|
template_name = (request.POST.get("template_name") or "").strip()
|
|
size = (request.POST.get("size") or "").strip()
|
|
if not design_id:
|
|
messages.error(request, "Missing design id.")
|
|
return redirect("messaging:postcard_designer")
|
|
if not template_name:
|
|
messages.error(request, "Template name is required.")
|
|
return redirect(
|
|
f"{reverse('messaging:postcard_designer')}?design_id={design_id}"
|
|
)
|
|
try:
|
|
design_id_int = int(design_id)
|
|
except ValueError:
|
|
messages.error(request, "Invalid design id.")
|
|
return redirect("messaging:postcard_designer")
|
|
|
|
front = {
|
|
"design_id": design_id_int,
|
|
"size": size,
|
|
"name": template_name,
|
|
"provider": "pcm",
|
|
}
|
|
tmpl, created = MessageTemplate.objects.update_or_create(
|
|
channel=Channel.POSTCARD,
|
|
name=template_name,
|
|
defaults={
|
|
"subject": "",
|
|
"body": f"PCM design {design_id_int}",
|
|
"postcard_front": front,
|
|
"postcard_back": {},
|
|
},
|
|
)
|
|
verb = "Created" if created else "Updated"
|
|
messages.success(
|
|
request,
|
|
f"{verb} postcard template “{tmpl.name}” (design {design_id_int}).",
|
|
)
|
|
return redirect(
|
|
f"{reverse('messaging:postcard_designer')}?design_id={design_id}"
|
|
)
|
|
|
|
|
|
@csrf_exempt
|
|
@require_POST
|
|
def postcard_webhook(request):
|
|
"""
|
|
PCM Integrations order / mail-tracking webhook.
|
|
|
|
Configure in PCM → Webhooks (one subscription per event):
|
|
URL: https://<host>/portal/messaging/webhooks/postcard/
|
|
Copy each subscription's signature secret into PCM_WEBHOOK_SECRETS
|
|
"""
|
|
if not _webhook_authorized(request, secrets=_pcm_webhook_secrets()):
|
|
return HttpResponseForbidden("invalid webhook token")
|
|
payload = parse_webhook_payload(request)
|
|
if not payload:
|
|
payload = request.POST.dict() or {}
|
|
event = process_pcm_postcard_webhook(payload)
|
|
return JsonResponse(
|
|
{
|
|
"ok": True,
|
|
"matched": bool(event and event.message_id),
|
|
"event_id": event.pk if event else None,
|
|
}
|
|
)
|
|
|
|
|
|
@csrf_exempt
|
|
@require_POST
|
|
def sms_webhook(request):
|
|
"""
|
|
SMTP2GO SMS webhook — delivery status events + inbound STOP replies.
|
|
|
|
Configure a *separate* webhook in SMTP2GO → Settings → Webhooks:
|
|
URL: https://<host>/portal/messaging/webhooks/sms/
|
|
Authorization header: Bearer + value = SMTP2GO_WEBHOOK_SECRET
|
|
Output type: JSON
|
|
SMS events: Submitted, Sending, Delivered, Failed, Rejected, Opt-out
|
|
(leave Email events unchecked on this webhook)
|
|
|
|
Inbound gateway POSTs without ``event`` (text=STOP, from=…) still opt out.
|
|
"""
|
|
if not _webhook_authorized(
|
|
request, secret=settings.SMTP2GO_WEBHOOK_SECRET or ""
|
|
):
|
|
return HttpResponseForbidden("invalid webhook token")
|
|
|
|
payload = parse_webhook_payload(request)
|
|
if not payload:
|
|
payload = request.POST.dict() or {}
|
|
|
|
# Inbound reply (STOP) — different payload shape than delivery events.
|
|
if is_inbound_sms_stop(payload):
|
|
phone = (
|
|
payload.get("from")
|
|
or payload.get("phone")
|
|
or payload.get("source_number")
|
|
or payload.get("destination_number")
|
|
or ""
|
|
)
|
|
stopped = bool(phone) and record_sms_stop(str(phone))
|
|
return JsonResponse({"ok": True, "opt_out": stopped})
|
|
|
|
event = process_smtp2go_sms_webhook(payload)
|
|
return JsonResponse(
|
|
{
|
|
"ok": True,
|
|
"matched": bool(event and event.message_id),
|
|
"event_id": event.pk if event else None,
|
|
}
|
|
)
|
|
|
|
|
|
@csrf_exempt
|
|
@require_POST
|
|
def email_webhook(request):
|
|
"""
|
|
SMTP2GO email event webhook (delivered / open / click / bounce / …).
|
|
|
|
Configure in SMTP2GO → Settings → Webhooks:
|
|
URL: https://<host>/portal/messaging/webhooks/email/
|
|
Authorization header: Bearer + value = SMTP2GO_WEBHOOK_SECRET
|
|
Output type: JSON
|
|
Email events: all delivery/engagement boxes
|
|
Email headers: X-Monica-Message-Id
|
|
"""
|
|
if not _webhook_authorized(
|
|
request, secret=settings.SMTP2GO_WEBHOOK_SECRET or ""
|
|
):
|
|
return HttpResponseForbidden("invalid webhook token")
|
|
payload = parse_webhook_payload(request)
|
|
try:
|
|
event = process_smtp2go_email_webhook(payload)
|
|
except Exception: # noqa: BLE001 — never 500 SMTP2GO (they retry for 48h)
|
|
logger.exception("SMTP2GO email webhook processing failed")
|
|
return JsonResponse({"ok": False, "error": "processing_failed"}, status=200)
|
|
return JsonResponse(
|
|
{
|
|
"ok": True,
|
|
"matched": bool(event and event.message_id),
|
|
"event_id": event.pk if event else None,
|
|
}
|
|
)
|