django-nativemojo 0.1.10__py3-none-any.whl → 0.1.16__py3-none-any.whl

mojo/apps/aws/models/mailbox.py

@@ -0,0 +1,288 @@
+from django.db import models
+from django.core.exceptions import ValidationError
+from mojo.models import MojoModel
+from typing import Optional, Union, Sequence, Dict, Any
+
+
+class Mailbox(models.Model, MojoModel):
+    """
+    Mailbox
+
+    Minimal model representing a single email address (mailbox) within a verified EmailDomain.
+    Sending and receiving policies are configured per mailbox. When inbound messages arrive
+    (domain-level catch-all), they are routed to the matching mailbox by recipient address and
+    optionally dispatched to an async handler.
+
+    Notes:
+    - `email` is the full email address (e.g., support@example.com) and is unique.
+    - `domain` references the owning EmailDomain (e.g., example.com).
+    - `allow_inbound` and `allow_outbound` control behavior for this mailbox.
+    - `async_handler` is a dotted path "package.module:function" used by the Tasks system.
+    - `metadata` allows flexible extension without schema churn.
+    """
+
+    created = models.DateTimeField(auto_now_add=True, editable=False)
+    modified = models.DateTimeField(auto_now=True, db_index=True)
+
+    domain = models.ForeignKey(
+        "EmailDomain",
+        related_name="mailboxes",
+        on_delete=models.CASCADE,
+        help_text="Owning email domain (SES identity)"
+    )
+
+    email = models.EmailField(
+        unique=True,
+        db_index=True,
+        help_text="Full email address for this mailbox (e.g., support@example.com)"
+    )
+
+    allow_inbound = models.BooleanField(
+        default=True,
+        help_text="If true, inbound messages addressed to this mailbox will be processed"
+    )
+    allow_outbound = models.BooleanField(
+        default=True,
+        help_text="If true, outbound messages can be sent from this mailbox"
+    )
+
+    async_handler = models.CharField(
+        max_length=255,
+        null=True,
+        blank=True,
+        help_text="Dotted path to async handler: 'package.module:function'"
+    )
+
+    metadata = models.JSONField(default=dict, blank=True)
+
+    is_system_default = models.BooleanField(
+        default=False,
+        db_index=True,
+        help_text="System-wide default mailbox (only one allowed)"
+    )
+
+    is_domain_default = models.BooleanField(
+        default=False,
+        db_index=True,
+        help_text="Default mailbox for this domain (one per domain)"
+    )
+
+    class Meta:
+        db_table = "aws_mailbox"
+        indexes = [
+            models.Index(fields=["modified"]),
+            models.Index(fields=["email"]),
+            models.Index(fields=["is_system_default"]),
+            models.Index(fields=["is_domain_default", "domain"]),
+        ]
+        ordering = ["email"]
+
+    class RestMeta:
+        VIEW_PERMS = ["manage_aws"]
+        SAVE_PERMS = ["manage_aws"]
+        DELETE_PERMS = ["manage_aws"]
+        SEARCH_FIELDS = ["email"]
+        GRAPHS = {
+            "basic": {
+                "fields": [
+                    "id",
+                    "email",
+                    "domain",
+                    "allow_inbound",
+                    "allow_outbound",
+                    "is_system_default",
+                    "is_domain_default",
+                ]
+            },
+            "default": {
+                "fields": [
+                    "id",
+                    "email",
+                    "domain",
+                    "allow_inbound",
+                    "allow_outbound",
+                    "async_handler",
+                    "metadata",
+                    "is_system_default",
+                    "is_domain_default",
+                    "created",
+                    "modified",
+                ],
+                "graphs": {
+                    "domain": "basic"
+                }
+            },
+        }
+
+    def __str__(self) -> str:
+        return self.email
+
+    def clean(self):
+        """
+        Ensure the mailbox email belongs to the associated domain (simple sanity check).
+        """
+        super().clean()
+        if self.domain and self.email:
+            domain_name = f"@{self.domain.name.lower()}"
+            if not self.email.lower().endswith(domain_name):
+                raise ValidationError(
+                    {"email": f"Email must belong to domain '{self.domain.name}'"}
+                )
+
+    def on_rest_saved(self, changed_fields, created):
+        """Handle default field uniqueness after REST save"""
+
+        # Clear other system defaults if this was just set as system default
+        if 'is_system_default' in changed_fields and self.is_system_default:
+            Mailbox.objects.exclude(pk=self.pk).update(is_system_default=False)
+
+        # Clear other domain defaults if this was just set as domain default
+        if 'is_domain_default' in changed_fields and self.is_domain_default:
+            Mailbox.objects.filter(domain=self.domain).exclude(pk=self.pk).update(is_domain_default=False)
+
+        super().on_rest_saved(changed_fields, created)
+
+    @classmethod
+    def get_system_default(cls) -> Optional['Mailbox']:
+        """Get the system-wide default mailbox"""
+        return cls.objects.filter(is_system_default=True).first()
+
+    @classmethod
+    def get_domain_default(cls, domain: Union[str, 'EmailDomain']) -> Optional['Mailbox']:
+        """Get the default mailbox for a specific domain
+
+        Args:
+            domain: Either a domain name string or EmailDomain instance
+        """
+        if isinstance(domain, str):
+            return cls.objects.filter(domain__name__iexact=domain, is_domain_default=True).first()
+        else:
+            return cls.objects.filter(domain=domain, is_domain_default=True).first()
+
+    @classmethod
+    def get_default(cls, domain: Optional[Union[str, 'EmailDomain']] = None, prefer_domain: bool = True) -> Optional['Mailbox']:
+        """Smart default: try domain default first (if domain provided), then fall back to system default
+
+        Args:
+            domain: Optional domain to look for domain-specific default
+            prefer_domain: If True (default), prefer domain default over system default
+        """
+        if domain and prefer_domain:
+            domain_default = cls.get_domain_default(domain)
+            if domain_default:
+                return domain_default
+
+        return cls.get_system_default()
+
+    def send_email(
+        self,
+        to: Union[str, Sequence[str]],
+        subject: Optional[str] = None,
+        body_text: Optional[str] = None,
+        body_html: Optional[str] = None,
+        cc: Optional[Union[str, Sequence[str]]] = None,
+        bcc: Optional[Union[str, Sequence[str]]] = None,
+        reply_to: Optional[Union[str, Sequence[str]]] = None,
+        **kwargs
+    ) -> 'SentMessage':
+        """Send plain email from this mailbox
+
+        Args:
+            to: One or more recipient addresses
+            subject: Email subject
+            body_text: Optional plain text body
+            body_html: Optional HTML body
+            cc, bcc, reply_to: Optional addressing
+            **kwargs: Additional arguments passed to email service (allow_unverified, aws_access_key, etc.)
+
+        Returns:
+            SentMessage instance
+
+        Raises:
+            OutboundNotAllowed: If this mailbox has allow_outbound=False
+        """
+        from mojo.apps.aws.services import email as email_service
+
+        if not self.allow_outbound:
+            raise email_service.OutboundNotAllowed(f"Outbound sending is disabled for mailbox {self.email}")
+
+        aws_access_key = self.domain.aws_key
+        aws_secret_key = self.domain.aws_secret
+        aws_region = self.domain.aws_region
+
+        return email_service.send_email(
+            from_email=self.email,
+            to=to,
+            subject=subject,
+            body_text=body_text,
+            body_html=body_html,
+            cc=cc,
+            bcc=bcc,
+            reply_to=reply_to,
+            aws_access_key=aws_access_key,
+            aws_secret_key=aws_secret_key,
+            region=aws_region,
+            **kwargs
+        )
+
+    def send_template_email(
+        self,
+        to: Union[str, Sequence[str]],
+        template_name: str,
+        context: Optional[Dict[str, Any]] = None,
+        cc: Optional[Union[str, Sequence[str]]] = None,
+        bcc: Optional[Union[str, Sequence[str]]] = None,
+        reply_to: Optional[Union[str, Sequence[str]]] = None,
+        **kwargs
+    ) -> 'SentMessage':
+        """Send email using DB EmailTemplate
+
+        Args:
+            to: One or more recipient addresses
+            template_name: Name of the EmailTemplate in database
+            context: Template context variables
+            cc, bcc, reply_to: Optional addressing
+            **kwargs: Additional arguments passed to email service (allow_unverified, aws_access_key, etc.)
+
+        Returns:
+            SentMessage instance
+
+        Raises:
+            OutboundNotAllowed: If this mailbox has allow_outbound=False
+            ValueError: If template not found
+
+        Note:
+            Automatically checks for domain-specific template overrides.
+            If "{domain.name}.{template_name}" exists, it will be used instead of the base template.
+        """
+        from mojo.apps.aws.services import email as email_service
+        from mojo.apps.aws.models import EmailTemplate
+
+        if not self.allow_outbound:
+            raise email_service.OutboundNotAllowed(f"Outbound sending is disabled for mailbox {self.email}")
+
+        # Check for domain-specific template override
+        final_template_name = template_name
+        if self.domain and self.domain.name:
+            domain_template_name = f"{self.domain.name}.{template_name}"
+            # Check if domain-specific template exists
+            if EmailTemplate.objects.filter(name=domain_template_name).exists():
+                final_template_name = domain_template_name
+
+        aws_access_key = self.domain.aws_access_key
+        aws_secret_key = self.domain.aws_secret_key
+        aws_region = self.domain.aws_region
+
+        return email_service.send_with_template(
+            from_email=self.email,
+            to=to,
+            template_name=final_template_name,
+            context=context,
+            cc=cc,
+            bcc=bcc,
+            reply_to=reply_to,
+            aws_access_key=aws_access_key,
+            aws_secret_key=aws_secret_key,
+            region=aws_region,
+            **kwargs
+        )

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

@@ -0,0 +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)