django-nativemojo 0.1.15__py3-none-any.whl → 0.1.17__py3-none-any.whl

mojo/apps/aws/models/sent_message.py

@@ -0,0 +1,175 @@
+from django.db import models
+from mojo.models import MojoModel
+
+
+class SentMessage(models.Model, MojoModel):
+    """
+    SentMessage
+
+    Represents an outbound email sent via AWS SES using a specific Mailbox (email address).
+    Tracks SES MessageId and delivery lifecycle (delivery, bounce, complaint) updated via SNS webhooks.
+
+    Notes:
+    - `mailbox` identifies the sending address; sending is only allowed when mailbox.allow_outbound is True.
+    - `ses_message_id` is populated after a successful SES send API call.
+    - `to_addresses`, `cc_addresses`, `bcc_addresses` are stored as JSON arrays.
+    - `template_name` and `template_context` support simple templated sending (EmailTemplate model can be added later).
+    - `status` reflects the current delivery state; `status_reason` stores detailed info (bounce/complaint payloads, errors).
+    """
+
+    STATUS_QUEUED = "queued"
+    STATUS_SENDING = "sending"
+    STATUS_DELIVERED = "delivered"
+    STATUS_BOUNCED = "bounced"
+    STATUS_COMPLAINED = "complained"
+    STATUS_FAILED = "failed"
+    STATUS_UNKNOWN = "unknown"
+
+    STATUS_CHOICES = [
+        (STATUS_QUEUED, "Queued"),
+        (STATUS_SENDING, "Sending"),
+        (STATUS_DELIVERED, "Delivered"),
+        (STATUS_BOUNCED, "Bounced"),
+        (STATUS_COMPLAINED, "Complained"),
+        (STATUS_FAILED, "Failed"),
+        (STATUS_UNKNOWN, "Unknown"),
+    ]
+
+    created = models.DateTimeField(auto_now_add=True, editable=False)
+    modified = models.DateTimeField(auto_now=True, db_index=True)
+
+    mailbox = models.ForeignKey(
+        "aws.Mailbox",
+        related_name="sent_messages",
+        on_delete=models.CASCADE,
+        help_text="Mailbox used as the sender (envelope MAIL FROM = mailbox.email)"
+    )
+
+    ses_message_id = models.CharField(
+        max_length=255,
+        null=True,
+        blank=True,
+        db_index=True,
+        help_text="AWS SES MessageId returned after a successful send"
+    )
+
+    # Recipients
+    to_addresses = models.JSONField(
+        default=list,
+        blank=True,
+        help_text="List of recipient addresses (To)"
+    )
+    cc_addresses = models.JSONField(
+        default=list,
+        blank=True,
+        help_text="List of recipient addresses (Cc)"
+    )
+    bcc_addresses = models.JSONField(
+        default=list,
+        blank=True,
+        help_text="List of recipient addresses (Bcc)"
+    )
+
+    # Content
+    subject = models.CharField(
+        max_length=512,
+        null=True,
+        blank=True,
+        help_text="Email subject"
+    )
+    body_text = models.TextField(
+        null=True,
+        blank=True,
+        help_text="Plain text body"
+    )
+    body_html = models.TextField(
+        null=True,
+        blank=True,
+        help_text="HTML body"
+    )
+
+    # Template support (simple; FK can be added later)
+    template_name = models.CharField(
+        max_length=255,
+        null=True,
+        blank=True,
+        help_text="Optional EmailTemplate name used to render this message"
+    )
+    template_context = models.JSONField(
+        default=dict,
+        blank=True,
+        help_text="Context used when rendering a template"
+    )
+
+    # Delivery status
+    status = models.CharField(
+        max_length=32,
+        choices=STATUS_CHOICES,
+        default=STATUS_QUEUED,
+        db_index=True,
+        help_text="Current delivery status"
+    )
+    status_reason = models.TextField(
+        null=True,
+        blank=True,
+        help_text="Details or raw payload for bounces/complaints/errors"
+    )
+
+    metadata = models.JSONField(
+        default=dict,
+        blank=True,
+        help_text="Arbitrary metadata for downstream processing/auditing"
+    )
+
+    class Meta:
+        db_table = "aws_sent_message"
+        indexes = [
+            models.Index(fields=["modified"]),
+            models.Index(fields=["status"]),
+            models.Index(fields=["ses_message_id"]),
+        ]
+        ordering = ["-created", "id"]
+
+    class RestMeta:
+        VIEW_PERMS = ["manage_aws"]
+        SAVE_PERMS = ["manage_aws"]
+        DELETE_PERMS = ["manage_aws"]
+        SEARCH_FIELDS = ["subject", "ses_message_id"]
+        GRAPHS = {
+            "basic": {
+                "fields": [
+                    "id",
+                    "mailbox",
+                    "ses_message_id",
+                    "subject",
+                    "to_addresses",
+                    "status",
+                    "created",
+                ],
+                "graphs": {"mailbox": "basic"}
+            },
+            "default": {
+                "fields": [
+                    "id",
+                    "mailbox",
+                    "ses_message_id",
+                    "to_addresses",
+                    "cc_addresses",
+                    "bcc_addresses",
+                    "subject",
+                    "body_text",
+                    "body_html",
+                    "template_name",
+                    "template_context",
+                    "status",
+                    "status_reason",
+                    "metadata",
+                    "created",
+                    "modified",
+                ],
+                "graphs": {"mailbox": "basic"}
+            },
+        }
+
+    def __str__(self) -> str:
+        return self.subject or self.ses_message_id or f"SentMessage {self.pk}"

mojo/apps/aws/rest/__init__.py

@@ -1 +1,7 @@
 from .s3 import *
+from .email import *
+from .email_ops import *
+from .messages import *
+from .sns import *
+from .send import *
+from .templates import *

mojo/apps/aws/rest/email.py

@@ -0,0 +1,33 @@
+from mojo import decorators as md
+from mojo.apps.aws.models import EmailDomain, Mailbox
+
+
+"""
+AWS Email REST Handlers
+
+Endpoints:
+- Domain CRUD:
+  - GET/POST/PUT/DELETE /aws/email/domain
+  - GET/POST/PUT/DELETE /aws/email/domain/<int:pk>
+
+- Mailbox CRUD:
+  - GET/POST/PUT/DELETE /aws/email/mailbox
+  - GET/POST/PUT/DELETE /aws/email/mailbox/<int:pk>
+
+These handlers delegate to the models' on_rest_request, which uses RestMeta for
+permission checks, graphs, and default CRUD behavior.
+"""
+
+
+@md.URL('email/domain')
+@md.URL('email/domain/<int:pk>')
+@md.requires_perms("manage_aws")
+def on_email_domain(request, pk=None):
+    return EmailDomain.on_rest_request(request, pk)
+
+
+@md.URL('email/mailbox')
+@md.URL('email/mailbox/<int:pk>')
+@md.requires_perms("manage_aws")
+def on_mailbox(request, pk=None):
+    return Mailbox.on_rest_request(request, pk)

mojo/apps/aws/rest/email_ops.py

@@ -0,0 +1,183 @@
+from typing import Dict, Any
+
+from mojo import decorators as md
+from mojo import JsonResponse
+from mojo.helpers import logit
+
+# Use the new email_ops service
+from mojo.apps.aws.services.email_ops import (
+    onboard_email_domain,
+    audit_email_domain,
+    reconcile_email_domain,
+    generate_audit_recommendations,
+    EmailDomainNotFound,
+    InvalidConfiguration,
+)
+
+logger = logit.get_logger("email", "email.log")
+
+
+def _get_json(request) -> Dict[str, Any]:
+    return getattr(request, "DATA", {}) or {}
+
+
+@md.URL("email/domain/<int:pk>/onboard")
+@md.requires_perms("manage_aws")
+def on_email_domain_onboard(request, pk: int):
+    """
+    Kick off domain onboarding:
+      - Request SES domain verification + DKIM tokens
+      - Compute required DNS records (manual or automated via GoDaddy if requested)
+      - Ensure SNS topics + notification mappings
+      - Optionally enable receiving (catch-all → S3 + SNS)
+      - Optionally enable MAIL FROM (returns DNS to add)
+    """
+    if request.method != "POST":
+        return JsonResponse({"error": "Method not allowed"}, status=405)
+
+    payload = _get_json(request)
+
+    try:
+        result = onboard_email_domain(
+            domain_pk=pk,
+            region=payload.get("region"),
+            receiving_enabled=payload.get("receiving_enabled"),
+            s3_bucket=payload.get("s3_inbound_bucket"),
+            s3_prefix=payload.get("s3_inbound_prefix"),
+            ensure_mail_from=bool(payload.get("ensure_mail_from", False)),
+            mail_from_subdomain=payload.get("mail_from_subdomain", "feedback"),
+            dns_mode=payload.get("dns_mode"),
+            endpoints=payload.get("endpoints") or {
+                "bounce": payload.get("bounce_endpoint"),
+                "complaint": payload.get("complaint_endpoint"),
+                "delivery": payload.get("delivery_endpoint"),
+                "inbound": payload.get("inbound_endpoint"),
+            },
+            access_key=payload.get("aws_access_key"),
+            secret_key=payload.get("aws_secret_key"),
+            godaddy_key=payload.get("godaddy_key"),
+            godaddy_secret=payload.get("godaddy_secret"),
+        )
+
+        return JsonResponse({
+            "status": True,
+            "data": {
+                "domain": result.domain,
+                "region": result.region,
+                "dns_records": result.dns_records,
+                "dkim_tokens": result.dkim_tokens,
+                "topic_arns": result.topic_arns,
+                "receipt_rule": result.receipt_rule,
+                "rule_set": result.rule_set,
+                "notes": result.notes,
+            }
+        })
+    except EmailDomainNotFound:
+        return JsonResponse({"error": "EmailDomain not found", "code": 404}, status=404)
+    except InvalidConfiguration as e:
+        return JsonResponse({"error": str(e)}, status=400)
+    except Exception as e:
+        logger.error(f"onboard error for domain pk={pk}: {e}")
+        return JsonResponse({"error": str(e)}, status=500)
+
+
+@md.URL("email/domain/<int:pk>/audit")
+@md.requires_perms("manage_aws")
+def on_email_domain_audit(request, pk: int):
+    """
+    Audit SES/SNS/S3 configuration for the domain and return a drift report.
+    Uses the model configuration to compute desired receiving.
+    """
+    if request.method not in ("GET", "POST"):
+        return JsonResponse({"error": "Method not allowed"}, status=405)
+
+    payload = _get_json(request) if request.method == "POST" else {}
+
+    try:
+        result = audit_email_domain(
+            domain_pk=pk,
+            region=payload.get("region"),
+            access_key=payload.get("aws_access_key"),
+            secret_key=payload.get("aws_secret_key"),
+            rule_set=payload.get("rule_set"),
+            rule_name=payload.get("rule_name"),
+        )
+
+        return JsonResponse({
+            "status": True,
+            "data": {
+                "domain": result.domain,
+                "region": result.region,
+                "status": result.status,
+                "audit_pass": result.audit_pass,
+                "checks": result.checks,
+                "items": [
+                    {
+                        "resource": it.resource,
+                        "desired": it.desired,
+                        "current": it.current,
+                        "status": it.status
+                    } for it in result.items
+                ],
+                "recommendations": generate_audit_recommendations(result.report)
+            }
+        })
+    except EmailDomainNotFound:
+        return JsonResponse({"error": "EmailDomain not found", "code": 404}, status=404)
+    except Exception as e:
+        logger.error(f"audit error for domain pk={pk}: {e}")
+        return JsonResponse({"error": str(e)}, status=500)
+
+
+@md.URL("email/domain/<int:pk>/reconcile")
+@md.requires_perms("manage_aws")
+def on_email_domain_reconcile(request, pk: int):
+    """
+    Attempt to reconcile SES/SNS for the domain:
+      - Ensure SNS topics and notification mappings
+      - Ensure receiving catch-all rule (if receiving_enabled)
+      - Optionally configure MAIL FROM
+    Does not modify DNS; use onboarding + DNS mode or apply manually.
+    """
+    if request.method != "POST":
+        return JsonResponse({"error": "Method not allowed"}, status=405)
+
+    payload = _get_json(request)
+
+    try:
+        result = reconcile_email_domain(
+            domain_pk=pk,
+            region=payload.get("region"),
+            receiving_enabled=payload.get("receiving_enabled"),
+            s3_bucket=payload.get("s3_inbound_bucket"),
+            s3_prefix=payload.get("s3_inbound_prefix"),
+            ensure_mail_from=bool(payload.get("ensure_mail_from", False)),
+            mail_from_subdomain=payload.get("mail_from_subdomain", "feedback"),
+            endpoints=payload.get("endpoints") or {
+                "bounce": payload.get("bounce_endpoint"),
+                "complaint": payload.get("complaint_endpoint"),
+                "delivery": payload.get("delivery_endpoint"),
+                "inbound": payload.get("inbound_endpoint"),
+            },
+            access_key=payload.get("aws_access_key"),
+            secret_key=payload.get("aws_secret_key"),
+        )
+
+        return JsonResponse({
+            "status": True,
+            "data": {
+                "domain": result.domain,
+                "region": result.region,
+                "topic_arns": result.topic_arns,
+                "receipt_rule": result.receipt_rule,
+                "rule_set": result.rule_set,
+                "notes": result.notes,
+            }
+        })
+    except EmailDomainNotFound:
+        return JsonResponse({"error": "EmailDomain not found", "code": 404}, status=404)
+    except InvalidConfiguration as e:
+        return JsonResponse({"error": str(e)}, status=400)
+    except Exception as e:
+        logger.error(f"reconcile error for domain pk={pk}: {e}")
+        return JsonResponse({"error": str(e)}, status=500)

mojo/apps/aws/rest/messages.py

@@ -0,0 +1,32 @@
+from mojo import decorators as md
+from mojo.apps.aws.models import IncomingEmail, SentMessage
+
+"""
+AWS Email Messages REST Handlers
+
+Endpoints:
+- Incoming emails (list/detail via model.on_rest_request):
+  - GET/POST/PUT/DELETE /email/incoming
+  - GET/POST/PUT/DELETE /email/incoming/<int:pk>
+
+- Sent messages (list/detail via model.on_rest_request):
+  - GET/POST/PUT/DELETE /email/sent
+  - GET/POST/PUT/DELETE /email/sent/<int:pk>
+
+All endpoints require the "manage_aws" permission and delegate to the models' on_rest_request
+for CRUD operations, leveraging RestMeta permissions and graphs.
+"""
+
+
+@md.URL('email/incoming')
+@md.URL('email/incoming/<int:pk>')
+@md.requires_perms("manage_aws")
+def on_incoming_email(request, pk=None):
+    return IncomingEmail.on_rest_request(request, pk)
+
+
+@md.URL('email/sent')
+@md.URL('email/sent/<int:pk>')
+@md.requires_perms("manage_aws")
+def on_sent_message(request, pk=None):
+    return SentMessage.on_rest_request(request, pk)

mojo/apps/aws/rest/send.py

@@ -0,0 +1,101 @@
+from mojo.apps.aws.services import send_template_email
+from typing import Any, Dict, List, Optional
+
+from mojo import decorators as md
+from mojo import JsonResponse
+from mojo.apps.aws.models import Mailbox, SentMessage, EmailDomain, EmailTemplate
+from mojo.helpers.aws.ses import EmailSender
+from mojo.helpers.settings import settings
+from mojo.helpers import logit
+
+logger = logit.get_logger("email", "email.log")
+
+
+def _as_list(value: Any) -> List[str]:
+    if value is None:
+        return []
+    if isinstance(value, (list, tuple)):
+        return [str(v).strip() for v in value if str(v).strip()]
+    return [str(value).strip()] if str(value).strip() else []
+
+
+@md.URL("email/send")
+@md.requires_perms("manage_aws")
+def on_send_email(request):
+    """
+    Send an email through AWS SES using a Mailbox resolved by from_email.
+
+    Request (POST JSON):
+    {
+      "from_email": "support@example.com",            // required, resolves Mailbox
+      "to": ["user@example.org"],                     // required (list or string)
+      "cc": [],                                       // optional
+      "bcc": [],                                      // optional
+      "subject": "Hello",                             // required if not using template_name
+      "body_text": "Text body",                       // optional
+      "body_html": "<p>HTML body</p>",                // optional
+      "reply_to": ["replies@example.com"],            // optional
+      "template_name": "db-template-optional",        // optional, uses DB EmailTemplate if provided
+      "ses_template_name": "ses-template-optional",   // optional, uses AWS SES managed template
+      "template_context": { ... },                    // optional, for DB/SES template context
+      "aws_access_key": "...",                        // optional, defaults to settings
+      "aws_secret_key": "...",                        // optional, defaults to settings
+      "allow_unverified": false                       // optional, allow send even if domain.status != 'verified'
+    }
+
+    Behavior:
+    - Resolves the Mailbox by from_email (case-insensitive).
+    - Ensures mailbox.allow_outbound is True.
+    - Uses mailbox.domain.region (or settings.AWS_REGION) to send via SES.
+    - If template_name is provided and matches a DB EmailTemplate, renders and uses EmailSender.send_email with the rendered subject/body.
+      If ses_template_name is provided, uses EmailSender.send_template_email (AWS SES managed template).
+      Otherwise uses EmailSender.send_email with subject/body_text/body_html.
+    - Creates a SentMessage row and updates with SES MessageId and status.
+    """
+    if request.method != "POST":
+        return JsonResponse({"error": "Method not allowed"}, status=405)
+
+    data: Dict[str, Any] = getattr(request, "DATA", {}) or {}
+
+    from_email = (data.get("from_email") or "").strip()
+    if not from_email:
+        return JsonResponse({"error": "from_email is required"}, status=400)
+
+    # Resolve Mailbox by email (case-insensitive)
+    mailbox = Mailbox.objects.select_related("domain").filter(email__iexact=from_email).first()
+    if not mailbox:
+        return JsonResponse({"error": f"Mailbox not found for from_email={from_email}", "code": 404}, status=404)
+
+    if not mailbox.allow_outbound:
+        return JsonResponse({"error": "Outbound sending is disabled for this mailbox", "code": 403}, status=403)
+
+
+    to = _as_list(data.get("to"))
+    cc = _as_list(data.get("cc"))
+    bcc = _as_list(data.get("bcc"))
+    reply_to = _as_list(data.get("reply_to")) or [from_email]
+
+    if not to:
+        return JsonResponse({"error": "At least one recipient in 'to' is required"}, status=400)
+
+    subject = (data.get("subject") or "").strip()
+    body_text = data.get("body_text")
+    body_html = data.get("body_html")
+    template_name = (data.get("template_name") or "").strip() or None
+    template_context = data.get("template_context") or {}
+
+    if template_name:
+        res = mailbox.send_template_email(
+            to, template_name, template_context,
+            cc, bcc, reply_to)
+    else:
+        res = mailbox.send_email(
+            to=to,
+            subject=subject,
+            body_text=body_text,
+            body_html=body_html,
+            cc=cc,
+            bcc=bcc,
+            reply_to=reply_to
+        )
+    return res.on_rest_get(request)