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

mojo/apps/account/services/push.py

@@ -0,0 +1,363 @@
+from mojo.helpers.settings import settings
+from mojo.helpers import logit, dates
+from mojo.apps.account.models import (
+    PushConfig, RegisteredDevice, NotificationTemplate,
+    NotificationDelivery, User
+)
+
+
+
+# Optional imports - will be imported only if needed
+try:
+    from pyfcm import FCMNotification
+    HAS_FCM = True
+except ImportError:
+    HAS_FCM = False
+    logit.warn("pyfcm not installed - FCM notifications disabled")
+
+try:
+    from apns2.client import APNsClient
+    from apns2.payload import Payload
+    from apns2.credentials import TokenCredentials
+    HAS_APNS = True
+except ImportError:
+    HAS_APNS = False
+    logit.warn("apns2 not installed - APNS notifications disabled")
+
+
+class PushNotificationService:
+    """
+    Central push notification service for account-specific push functionality.
+
+    FCM is the primary service supporting both iOS and Android platforms.
+    APNS is available for iOS-specific requirements but rarely needed.
+    Test mode allows fake notifications for development and testing.
+    """
+
+    def __init__(self, user):
+        self.user = user
+        self.config = self._get_push_config()
+
+    def _get_push_config(self):
+        """Get push config for user's organization or system default."""
+        return PushConfig.get_for_user(self.user)
+
+    def send_notification(self, template_name=None, context=None, devices=None, user_ids=None,
+                         title=None, body=None, category="general", action_url=None, data=None):
+        """
+        Send notification using template or direct content.
+
+        Args:
+            template_name: Name of notification template (for templated sending)
+            context: Variables for template rendering
+            devices: Specific RegisteredDevice queryset/list
+            user_ids: List of user IDs to send to (uses their active devices)
+            title: Direct title (for non-templated sending)
+            body: Direct body (for non-templated sending)
+            category: Notification category
+            action_url: Direct action URL
+            data: Custom data payload dict
+
+        Returns:
+            List of NotificationDelivery objects
+        """
+        if not self.config:
+            logit.info(f"No push config available for user {self.user.username}")
+            return []
+
+        # Support both templated and direct sending
+        template = None
+        if template_name:
+            template = self._get_template(template_name)
+            if not template:
+                logit.error(f"Template {template_name} not found")
+                return []
+        elif not (title or body or data):
+            logit.error("Must provide either template_name, title/body, or data payload")
+            return []
+
+        target_devices = self._resolve_devices(devices, user_ids)
+        if not target_devices:
+            logit.info(f"No devices to send to for template {template_name or 'direct'}")
+            return []
+
+        results = []
+        for device in target_devices:
+            notification_category = template.category if template else category
+            if self._should_send_to_device(device, notification_category):
+                if template:
+                    result = self._send_to_device(device, template, context or {}, data)
+                else:
+                    result = self._send_direct(device, title, body, notification_category, action_url, data)
+                results.append(result)
+
+        return results
+
+    def _get_template(self, template_name):
+        """Get template by name, preferring user's org templates."""
+        # Try user's org first
+        if self.user.org:
+            template = NotificationTemplate.objects.filter(
+                group=self.user.org, name=template_name, is_active=True
+            ).first()
+            if template:
+                return template
+
+        # Fallback to system templates
+        return NotificationTemplate.objects.filter(
+            group__isnull=True, name=template_name, is_active=True
+        ).first()
+
+    def _resolve_devices(self, devices, user_ids):
+        """Resolve target devices from various inputs."""
+        if devices is not None:
+            return devices
+
+        if user_ids:
+            users = User.objects.filter(id__in=user_ids)
+            return RegisteredDevice.objects.filter(
+                user__in=users, is_active=True, push_enabled=True
+            )
+
+        # Default to current user's devices
+        return self.user.registered_devices.filter(
+            is_active=True, push_enabled=True
+        )
+
+    def _should_send_to_device(self, device, category):
+        """Check if device should receive this category of notification."""
+        preferences = device.push_preferences or {}
+        return preferences.get(category, True)  # Default to enabled
+
+    def _send_to_device(self, device, template, context, custom_data=None):
+        """Send notification to a specific device using template."""
+        title, body, action_url, template_data = template.render(context)
+
+        # Merge template data with custom data (custom data takes precedence)
+        merged_data = template_data.copy() if template_data else {}
+        if custom_data:
+            merged_data.update(custom_data)
+
+        delivery = NotificationDelivery.objects.create(
+            user=device.user,
+            device=device,
+            template=template,
+            title=title,
+            body=body,
+            category=template.category,
+            action_url=action_url,
+            data_payload=merged_data
+        )
+
+        self._attempt_delivery(delivery, device, title, body, template)
+        return delivery
+
+    def _send_direct(self, device, title, body, category, action_url=None, data=None):
+        """Send direct notification without template."""
+        delivery = NotificationDelivery.objects.create(
+            user=device.user,
+            device=device,
+            title=title,
+            body=body,
+            category=category,
+            action_url=action_url,
+            data_payload=data or {}
+        )
+
+        self._attempt_delivery(delivery, device, title, body, None)
+        return delivery
+
+    def _attempt_delivery(self, delivery, device, title, body, template):
+        """Attempt to deliver notification to device."""
+        try:
+            success = False
+
+            # Test mode - fake delivery for development/testing
+            if self.config.test_mode:
+                success = self._send_test(delivery, device, title, body, template)
+
+            # FCM is primary - supports both iOS and Android
+            elif self.config.fcm_enabled:
+                success = self._send_fcm(delivery, device, title, body, template)
+
+            # APNS fallback for iOS only (rarely needed)
+            elif device.platform == 'ios' and self.config.apns_enabled:
+                success = self._send_apns(delivery, device, title, body, template)
+
+            else:
+                error_msg = "No push service configured"
+                if not self.config.fcm_enabled and not self.config.apns_enabled:
+                    error_msg = "No push services enabled in config"
+                elif device.platform not in ['ios', 'android', 'web']:
+                    error_msg = f"Unsupported platform: {device.platform}"
+                delivery.mark_failed(error_msg)
+                return
+
+            if success:
+                delivery.mark_sent()
+            else:
+                delivery.mark_failed("Platform delivery failed")
+
+        except Exception as e:
+            error_msg = f"Push notification failed: {str(e)}"
+            logit.error(error_msg)
+            delivery.mark_failed(error_msg)
+
+    def _send_apns(self, delivery, device, title, body, template):
+        """Send APNS notification to iOS device."""
+        if not HAS_APNS:
+            logit.error("APNS support not available - apns2 package not installed")
+            return False
+
+        try:
+            credentials = TokenCredentials(
+                auth_key=self.config.get_decrypted_apns_key(),
+                auth_key_id=self.config.apns_key_id,
+                team_id=self.config.apns_team_id
+            )
+
+            client = APNsClient(credentials=credentials,
+                              use_sandbox=self.config.apns_use_sandbox)
+
+            # Build payload - handle optional title/body for silent notifications
+            if title or body:
+                alert = {}
+                if title:
+                    alert['title'] = title
+                if body:
+                    alert['body'] = body
+                payload = Payload(
+                    alert=alert,
+                    sound=self.config.default_sound,
+                    badge=self.config.default_badge_count
+                )
+            else:
+                # Silent notification - no alert, sound, or badge
+                payload = Payload(
+                    content_available=True
+                )
+
+            # Build custom data payload - merge custom data with action_url
+            custom_data = delivery.data_payload.copy() if delivery.data_payload else {}
+            if delivery.action_url:
+                custom_data['action_url'] = delivery.action_url
+
+            if custom_data:
+                payload.custom = custom_data
+
+            # Send notification
+            response = client.send_notification(
+                device.device_token,
+                payload,
+                self.config.apns_bundle_id
+            )
+
+            # Store platform response data
+            delivery.platform_data = {
+                'apns_id': response.id if hasattr(response, 'id') else None,
+                'status': response.status if hasattr(response, 'status') else 'sent'
+            }
+            delivery.save(update_fields=['platform_data'])
+
+            return True
+
+        except Exception as e:
+            logit.error(f"APNS send failed: {e}")
+            return False
+
+    def _send_fcm(self, delivery, device, title, body, template):
+        """Send FCM notification to device (supports both iOS and Android)."""
+        if not HAS_FCM:
+            logit.error("FCM support not available - pyfcm package not installed")
+            return False
+
+        try:
+            push_service = FCMNotification(api_key=self.config.get_decrypted_fcm_key())
+
+            # Build data payload - merge custom data with action_url
+            data_message = delivery.data_payload.copy() if delivery.data_payload else {}
+            if delivery.action_url:
+                data_message['action_url'] = delivery.action_url
+
+            result = push_service.notify_single_device(
+                registration_id=device.device_token,
+                message_title=title,
+                message_body=body,
+                sound=self.config.default_sound if (title or body) else None,
+                data_message=data_message if data_message else None
+            )
+
+            # Store platform response data
+            delivery.platform_data = {
+                'multicast_id': result.get('multicast_id'),
+                'success': result.get('success', 0),
+                'failure': result.get('failure', 0),
+                'results': result.get('results', [])
+            }
+            delivery.save(update_fields=['platform_data'])
+
+            return result.get('success', 0) > 0
+
+        except Exception as e:
+            logit.error(f"FCM send failed: {e}")
+            return False
+
+    def _send_test(self, delivery, device, title, body, template):
+        """Send fake notification for testing - always succeeds."""
+        # Build log message with optional title/body and data payload
+        log_parts = []
+        if title:
+            log_parts.append(f"Title: {title}")
+        if body:
+            log_parts.append(f"Body: {body}")
+        if delivery.data_payload:
+            log_parts.append(f"Data: {delivery.data_payload}")
+
+        log_message = f"TEST MODE: Fake notification to {device.platform} device '{device.device_name}'"
+        if log_parts:
+            log_message += f" - {' | '.join(log_parts)}"
+
+        logit.info(log_message)
+
+        # Store fake test data including data payload
+        delivery.platform_data = {
+            'test_mode': True,
+            'platform': device.platform,
+            'device_name': device.device_name,
+            'timestamp': dates.utcnow().isoformat(),
+            'fake_delivery': 'success',
+            'data_payload': delivery.data_payload or {}
+        }
+        delivery.save(update_fields=['platform_data'])
+
+        return True
+
+
+# Convenience functions for easy usage
+def send_push_notification(user, template_name, context=None, devices=None, user_ids=None, data=None, delay=None):
+    """
+    Send templated push notification.
+
+    Usage:
+        send_push_notification(user, 'welcome', {'name': user.display_name})
+        send_push_notification(user, 'alert', user_ids=[1, 2, 3])
+        send_push_notification(user, 'order_update', {'order_id': '123'}, data={'action': 'view_order'})
+    """
+    service = PushNotificationService(user)
+    return service.send_notification(template_name=template_name, context=context,
+                                   devices=devices, user_ids=user_ids, data=data)
+
+
+def send_direct_notification(user, title=None, body=None, category="general", action_url=None,
+                           data=None, devices=None, user_ids=None, delay=None):
+    """
+    Send direct push notification without template.
+
+    Usage:
+        send_direct_notification(user, "Hello!", "Your order is ready", "orders")
+        send_direct_notification(user, "Alert", "System maintenance", user_ids=[1, 2, 3])
+        send_direct_notification(user, data={"action": "sync", "silent": True})
+    """
+    service = PushNotificationService(user)
+    return service.send_notification(title=title, body=body, category=category,
+                                   action_url=action_url, data=data, devices=devices, user_ids=user_ids)

mojo/apps/aws/migrations/0001_initial.py

@@ -0,0 +1,206 @@
+# Generated by Django 4.2.21 on 2025-08-27 18:23
+
+from django.db import migrations, models
+import django.db.models.deletion
+import mojo.models.rest
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='EmailAttachment',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('created', models.DateTimeField(auto_now_add=True)),
+                ('modified', models.DateTimeField(auto_now=True, db_index=True)),
+                ('filename', models.CharField(blank=True, help_text='Original filename (if provided by the sender)', max_length=512, null=True)),
+                ('content_type', models.CharField(blank=True, help_text='MIME content type (e.g., application/pdf)', max_length=255, null=True)),
+                ('size_bytes', models.IntegerField(default=0, help_text='Size of the stored attachment in bytes (approximate)')),
+                ('stored_as', models.CharField(help_text='Storage reference (e.g., s3://bucket/key)', max_length=512)),
+                ('metadata', models.JSONField(blank=True, default=dict, help_text='Arbitrary metadata (e.g., content-id, part headers)')),
+            ],
+            options={
+                'db_table': 'aws_email_attachment',
+                'ordering': ['-created', 'id'],
+            },
+            bases=(models.Model, mojo.models.rest.MojoModel),
+        ),
+        migrations.CreateModel(
+            name='EmailDomain',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('mojo_secrets', models.TextField(blank=True, default=None, null=True)),
+                ('created', models.DateTimeField(auto_now_add=True)),
+                ('modified', models.DateTimeField(auto_now=True, db_index=True)),
+                ('name', models.CharField(db_index=True, max_length=255, unique=True)),
+                ('region', models.CharField(default='us-west-2', help_text='AWS region for SES operations', max_length=64)),
+                ('status', models.CharField(db_index=True, default='pending', help_text='High-level status: pending, verified, error (free-form)', max_length=32)),
+                ('receiving_enabled', models.BooleanField(default=False, help_text='When true, domain-level catch-all receiving is enabled via SES receipt rules')),
+                ('s3_inbound_bucket', models.CharField(blank=True, help_text='S3 bucket for inbound emails (required if receiving_enabled)', max_length=255, null=True)),
+                ('s3_inbound_prefix', models.CharField(blank=True, default='', help_text='S3 prefix for inbound emails (e.g., inbound/example.com/)', max_length=255)),
+                ('dns_mode', models.CharField(default='manual', help_text='DNS automation mode: manual | route53 | godaddy', max_length=32)),
+                ('sns_topic_bounce_arn', models.CharField(blank=True, help_text='SNS topic ARN for SES bounce notifications', max_length=512, null=True)),
+                ('sns_topic_complaint_arn', models.CharField(blank=True, help_text='SNS topic ARN for SES complaint notifications', max_length=512, null=True)),
+                ('sns_topic_delivery_arn', models.CharField(blank=True, help_text='SNS topic ARN for SES delivery notifications', max_length=512, null=True)),
+                ('sns_topic_inbound_arn', models.CharField(blank=True, help_text='SNS topic ARN for SES inbound notifications', max_length=512, null=True)),
+                ('metadata', models.JSONField(blank=True, default=dict)),
+            ],
+            options={
+                'db_table': 'aws_email_domain',
+                'ordering': ['name'],
+            },
+            bases=(models.Model, mojo.models.rest.MojoModel),
+        ),
+        migrations.CreateModel(
+            name='Mailbox',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('created', models.DateTimeField(auto_now_add=True)),
+                ('modified', models.DateTimeField(auto_now=True, db_index=True)),
+                ('email', models.EmailField(db_index=True, help_text='Full email address for this mailbox (e.g., support@example.com)', max_length=254, unique=True)),
+                ('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(blank=True, help_text="Dotted path to async handler: 'package.module:function'", max_length=255, null=True)),
+                ('metadata', models.JSONField(blank=True, default=dict)),
+                ('domain', models.ForeignKey(help_text='Owning email domain (SES identity)', on_delete=django.db.models.deletion.CASCADE, related_name='mailboxes', to='aws.emaildomain')),
+            ],
+            options={
+                'db_table': 'aws_mailbox',
+                'ordering': ['email'],
+            },
+            bases=(models.Model, mojo.models.rest.MojoModel),
+        ),
+        migrations.CreateModel(
+            name='SentMessage',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('created', models.DateTimeField(auto_now_add=True)),
+                ('modified', models.DateTimeField(auto_now=True, db_index=True)),
+                ('ses_message_id', models.CharField(blank=True, db_index=True, help_text='AWS SES MessageId returned after a successful send', max_length=255, null=True)),
+                ('to_addresses', models.JSONField(blank=True, default=list, help_text='List of recipient addresses (To)')),
+                ('cc_addresses', models.JSONField(blank=True, default=list, help_text='List of recipient addresses (Cc)')),
+                ('bcc_addresses', models.JSONField(blank=True, default=list, help_text='List of recipient addresses (Bcc)')),
+                ('subject', models.CharField(blank=True, help_text='Email subject', max_length=512, null=True)),
+                ('body_text', models.TextField(blank=True, help_text='Plain text body', null=True)),
+                ('body_html', models.TextField(blank=True, help_text='HTML body', null=True)),
+                ('template_name', models.CharField(blank=True, help_text='Optional EmailTemplate name used to render this message', max_length=255, null=True)),
+                ('template_context', models.JSONField(blank=True, default=dict, help_text='Context used when rendering a template')),
+                ('status', models.CharField(choices=[('queued', 'Queued'), ('sending', 'Sending'), ('delivered', 'Delivered'), ('bounced', 'Bounced'), ('complained', 'Complained'), ('failed', 'Failed'), ('unknown', 'Unknown')], db_index=True, default='queued', help_text='Current delivery status', max_length=32)),
+                ('status_reason', models.TextField(blank=True, help_text='Details or raw payload for bounces/complaints/errors', null=True)),
+                ('metadata', models.JSONField(blank=True, default=dict, help_text='Arbitrary metadata for downstream processing/auditing')),
+                ('mailbox', models.ForeignKey(help_text='Mailbox used as the sender (envelope MAIL FROM = mailbox.email)', on_delete=django.db.models.deletion.CASCADE, related_name='sent_messages', to='aws.mailbox')),
+            ],
+            options={
+                'db_table': 'aws_sent_message',
+                'ordering': ['-created', 'id'],
+            },
+            bases=(models.Model, mojo.models.rest.MojoModel),
+        ),
+        migrations.CreateModel(
+            name='IncomingEmail',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('created', models.DateTimeField(auto_now_add=True)),
+                ('modified', models.DateTimeField(auto_now=True, db_index=True)),
+                ('s3_object_url', models.CharField(help_text='S3 URL for the raw MIME message (e.g., s3://bucket/key)', max_length=512)),
+                ('message_id', models.CharField(blank=True, db_index=True, help_text='SMTP Message-ID header (if present)', max_length=255, null=True)),
+                ('from_address', models.CharField(blank=True, help_text='Raw From header address (may include name)', max_length=512, null=True)),
+                ('to_addresses', models.JSONField(blank=True, default=list, help_text='List of recipient addresses from To header')),
+                ('cc_addresses', models.JSONField(blank=True, default=list, help_text='List of recipient addresses from Cc header')),
+                ('subject', models.CharField(blank=True, help_text='Email subject', max_length=512, null=True)),
+                ('date_header', models.DateTimeField(blank=True, help_text='Parsed Date header from the message', null=True)),
+                ('headers', models.JSONField(blank=True, default=dict, help_text='All headers as a JSON object (flattened)')),
+                ('text_body', models.TextField(blank=True, help_text='Extracted plain text body (if available)', null=True)),
+                ('html_body', models.TextField(blank=True, help_text='Extracted HTML body (if available)', null=True)),
+                ('size_bytes', models.IntegerField(default=0, help_text='Approximate size of the raw message in bytes')),
+                ('received_at', models.DateTimeField(blank=True, db_index=True, help_text='Time message was received (from SNS/S3 event or set by parser)', null=True)),
+                ('processed', models.BooleanField(default=False, help_text='True if post-receive processing completed')),
+                ('process_status', models.CharField(db_index=True, default='pending', help_text='Processing status: pending | success | error', max_length=32)),
+                ('process_error', models.TextField(blank=True, help_text='Error details if processing failed', null=True)),
+                ('mailbox', models.ForeignKey(blank=True, help_text='Associated mailbox if any recipient matches', null=True, on_delete=django.db.models.deletion.CASCADE, related_name='incoming_emails', to='aws.mailbox')),
+            ],
+            options={
+                'db_table': 'aws_incoming_email',
+                'ordering': ['-received_at', '-created'],
+            },
+            bases=(models.Model, mojo.models.rest.MojoModel),
+        ),
+        migrations.CreateModel(
+            name='EmailTemplate',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('created', models.DateTimeField(auto_now_add=True)),
+                ('modified', models.DateTimeField(auto_now=True, db_index=True)),
+                ('name', models.CharField(db_index=True, help_text='Unique template name (used by callers to reference this template)', max_length=255, unique=True)),
+                ('subject_template', models.TextField(blank=True, default='', help_text='Django template string for the email subject')),
+                ('html_template', models.TextField(blank=True, default='', help_text='Django template string for the HTML body')),
+                ('text_template', models.TextField(blank=True, default='', help_text='Django template string for the plain text body')),
+                ('metadata', models.JSONField(blank=True, default=dict, help_text='Arbitrary metadata for this template (e.g., description, tags)')),
+            ],
+            options={
+                'db_table': 'aws_email_template',
+                'ordering': ['name'],
+                'indexes': [models.Index(fields=['modified'], name='aws_email_t_modifie_cf76d6_idx'), models.Index(fields=['name'], name='aws_email_t_name_d1662a_idx')],
+            },
+            bases=(models.Model, mojo.models.rest.MojoModel),
+        ),
+        migrations.AddIndex(
+            model_name='emaildomain',
+            index=models.Index(fields=['status'], name='aws_email_d_status_398945_idx'),
+        ),
+        migrations.AddIndex(
+            model_name='emaildomain',
+            index=models.Index(fields=['modified'], name='aws_email_d_modifie_66ca75_idx'),
+        ),
+        migrations.AddField(
+            model_name='emailattachment',
+            name='incoming_email',
+            field=models.ForeignKey(help_text='The inbound email this attachment belongs to', on_delete=django.db.models.deletion.CASCADE, related_name='attachments', to='aws.incomingemail'),
+        ),
+        migrations.AddIndex(
+            model_name='sentmessage',
+            index=models.Index(fields=['modified'], name='aws_sent_me_modifie_a26352_idx'),
+        ),
+        migrations.AddIndex(
+            model_name='sentmessage',
+            index=models.Index(fields=['status'], name='aws_sent_me_status_63e619_idx'),
+        ),
+        migrations.AddIndex(
+            model_name='sentmessage',
+            index=models.Index(fields=['ses_message_id'], name='aws_sent_me_ses_mes_b72855_idx'),
+        ),
+        migrations.AddIndex(
+            model_name='mailbox',
+            index=models.Index(fields=['modified'], name='aws_mailbox_modifie_597f5d_idx'),
+        ),
+        migrations.AddIndex(
+            model_name='mailbox',
+            index=models.Index(fields=['email'], name='aws_mailbox_email_e2c6d1_idx'),
+        ),
+        migrations.AddIndex(
+            model_name='incomingemail',
+            index=models.Index(fields=['modified'], name='aws_incomin_modifie_8e68a9_idx'),
+        ),
+        migrations.AddIndex(
+            model_name='incomingemail',
+            index=models.Index(fields=['received_at'], name='aws_incomin_receive_7b6d93_idx'),
+        ),
+        migrations.AddIndex(
+            model_name='incomingemail',
+            index=models.Index(fields=['message_id'], name='aws_incomin_message_d8ca7f_idx'),
+        ),
+        migrations.AddIndex(
+            model_name='emailattachment',
+            index=models.Index(fields=['modified'], name='aws_email_a_modifie_b283df_idx'),
+        ),
+        migrations.AddIndex(
+            model_name='emailattachment',
+            index=models.Index(fields=['filename'], name='aws_email_a_filenam_da3c89_idx'),
+        ),
+    ]

mojo/apps/aws/migrations/0002_emaildomain_can_recv_emaildomain_can_send_and_more.py

@@ -0,0 +1,28 @@
+# Generated by Django 4.2.21 on 2025-08-27 21:38
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('aws', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='emaildomain',
+            name='can_recv',
+            field=models.BooleanField(default=False, help_text='True if inbound receiving is ready per last audit'),
+        ),
+        migrations.AddField(
+            model_name='emaildomain',
+            name='can_send',
+            field=models.BooleanField(default=False, help_text='True if outbound sending is ready per last audit'),
+        ),
+        migrations.AlterField(
+            model_name='emaildomain',
+            name='status',
+            field=models.CharField(db_index=True, default='pending', help_text='Domain status: "pending" (created), "ready" (audit passed), or "missing" (audit failed)', max_length=32),
+        ),
+    ]

mojo/apps/aws/migrations/0003_mailbox_is_domain_default_mailbox_is_system_default_and_more.py

@@ -0,0 +1,31 @@
+# Generated by Django 4.2.21 on 2025-08-31 23:09
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('aws', '0002_emaildomain_can_recv_emaildomain_can_send_and_more'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='mailbox',
+            name='is_domain_default',
+            field=models.BooleanField(db_index=True, default=False, help_text='Default mailbox for this domain (one per domain)'),
+        ),
+        migrations.AddField(
+            model_name='mailbox',
+            name='is_system_default',
+            field=models.BooleanField(db_index=True, default=False, help_text='System-wide default mailbox (only one allowed)'),
+        ),
+        migrations.AddIndex(
+            model_name='mailbox',
+            index=models.Index(fields=['is_system_default'], name='aws_mailbox_is_syst_9911c7_idx'),
+        ),
+        migrations.AddIndex(
+            model_name='mailbox',
+            index=models.Index(fields=['is_domain_default', 'domain'], name='aws_mailbox_is_doma_189efb_idx'),
+        ),
+    ]

mojo/apps/aws/migrations/0004_s3bucket.py

@@ -0,0 +1,39 @@
+# Generated by Django 4.2.23 on 2025-09-06 00:00
+
+from django.conf import settings
+from django.db import migrations, models
+import django.db.models.deletion
+import mojo.models.rest
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+        ('account', '0014_notificationdelivery_data_payload_and_more'),
+        ('aws', '0003_mailbox_is_domain_default_mailbox_is_system_default_and_more'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='S3Bucket',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('mojo_secrets', models.TextField(blank=True, default=None, null=True)),
+                ('created', models.DateTimeField(auto_now_add=True)),
+                ('modified', models.DateTimeField(auto_now=True, db_index=True)),
+                ('name', models.CharField(db_index=True, max_length=255, unique=True)),
+                ('region', models.CharField(default='us-west-2', help_text='AWS region for SES operations', max_length=64)),
+                ('metadata', models.JSONField(blank=True, default=dict)),
+                ('is_active', models.BooleanField(db_index=True, default=False)),
+                ('is_system_default', models.BooleanField(db_index=True, default=False)),
+                ('is_group_default', models.BooleanField(db_index=True, default=False)),
+                ('group', models.ForeignKey(default=None, null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='s3_buckets', to='account.group')),
+                ('user', models.ForeignKey(default=None, null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='s3_buckets', to=settings.AUTH_USER_MODEL)),
+            ],
+            options={
+                'abstract': False,
+            },
+            bases=(models.Model, mojo.models.rest.MojoModel),
+        ),
+    ]