django-nativemojo 0.1.10__py3-none-any.whl

mojo/apps/notify/models/template.py

@@ -0,0 +1,30 @@
+from django.db import models
+from django.template import Context
+from django.template import Template
+from mojo.models import MojoModel
+
+
+try:
+    import css_inline
+    inliner = css_inline.CSSInliner(remove_style_tags=True)
+except Exception:
+    inliner = None
+
+
+class NotifyTemplate(models.Model, MojoModel):
+    created = models.DateTimeField(auto_now_add=True, editable=False)
+    modified = models.DateTimeField(auto_now=True)
+    group = models.ForeignKey("account.Group", blank=True, null=True, default=None,
+        related_name="templates", on_delete=models.CASCADE)
+    name = models.CharField(max_length=255, db_index=True)
+    kind = models.CharField(max_length=124, default="email")
+    template = models.TextField()
+
+    def render(self, context):
+        template = Template(self.template)
+        if context is None:
+            context = {}
+        context = Context(context)
+        if inliner is not None:
+            return inliner.inline(template.render(context))
+        return template.render(context)

mojo/apps/notify/providers/aws.py

@@ -0,0 +1,73 @@
+from mojo.helpers.settings import settings
+from mojo.helpers.logit import get_logger
+import metrics
+import boto3
+from . import render as mr
+
+# Initialize logger for email notifications
+EMAIL_LOGGER = get_logger("email", filename="email.log")
+
+# Retrieve SES settings from configuration
+SES_ACCESS_KEY = settings.SES_ACCESS_KEY
+SES_SECRET_KEY = settings.SES_SECRET_KEY
+SES_REGION = settings.SES_REGION
+EMAIL_METRICS = settings.EMAIL_METRICS
+EMAIL_ASYNC_AS_TASK = settings.EMAIL_ASYNC_AS_TASK
+
+def get_ses_client(access_key, secret_key, region):
+    """Create a new SES client with the provided credentials."""
+    return boto3.client('ses',
+                        aws_access_key_id=access_key,
+                        aws_secret_access_key=secret_key,
+                        region_name=region)
+
+def send_mail_via_ses(msg, sender, recipients, fail_silently=True):
+    """Send an email using Amazon SES service."""
+    try:
+        ses_client = get_ses_client(SES_ACCESS_KEY, SES_SECRET_KEY, SES_REGION)
+        ses_client.send_raw_email(
+            Source=sender,
+            Destinations=recipients,
+            RawMessage={'Data': msg.as_string()}
+        )
+        if EMAIL_METRICS:
+            metrics.record("emails_sent", category="email", min_granularity="hourly")
+        return True
+    except Exception as err:
+        if EMAIL_METRICS:
+            metrics.record("email_errors", category="email", min_granularity="hourly")
+        EMAIL_LOGGER.exception(err)
+        EMAIL_LOGGER.error(msg.as_string())
+        if not fail_silently:
+            raise err
+    return False
+
+def send_mail(msg, sender, recipients, fail_silently=True):
+    """Send an email via SES, defaulting to fail silently."""
+    return send_mail_via_ses(msg, sender, recipients, fail_silently)
+
+def send(sender, recipients, subject, message, attachments=None, replyto=None, fail_silently=False, do_async=False):
+    """
+    Prepare and send an email message.
+
+    :param sender: Email address of the sender.
+    :param recipients: List of recipient email addresses.
+    :param subject: Subject of the email.
+    :param message: Body of the email.
+    :param attachments: List of attachments.
+    :param replyto: Email address to reply to.
+    :param fail_silently: Flag to suppress exceptions.
+    :param do_async: Flag to send email asynchronously (not implemented).
+    """
+    html = None
+    text = None
+
+    if mr.isHTML(message):
+        html = message
+    else:
+        text = message
+
+    msg = mr.createMessage(sender, recipients, subject, text, html,
+                           attachments=attachments, replyto=replyto)
+
+    return send_mail(msg.msg, msg.sender, msg.recipients, fail_silently=fail_silently)

mojo/apps/notify/utils/__init__.py

@@ -0,0 +1,2 @@
+from .render import render_template  # noqa: F401
+from .parsing import *  # noqa: F401

mojo/apps/notify/utils/notifications.py

@@ -0,0 +1,404 @@
+from django.utils import timezone
+from django.db import transaction
+from django.core.exceptions import ValidationError
+from typing import Optional, Dict, Any, List, Union
+import logging
+
+from ..models import Account, Inbox, InboxMessage, Outbox, OutboxMessage
+
+
+logger = logging.getLogger(__name__)
+
+
+class NotificationError(Exception):
+    """Base exception for notification errors"""
+    pass
+
+
+class MessageSender:
+    """
+    High-level interface for sending messages through various notification channels
+    """
+    
+    @staticmethod
+    def send_email(
+        to_address: str,
+        subject: str,
+        message: str,
+        from_address: Optional[str] = None,
+        group=None,
+        user=None,
+        metadata: Optional[Dict[str, Any]] = None,
+        scheduled_at: Optional[timezone.datetime] = None
+    ) -> OutboxMessage:
+        """Send an email message"""
+        return MessageSender._send_message(
+            kind=Account.EMAIL,
+            to_address=to_address,
+            subject=subject,
+            message=message,
+            from_address=from_address,
+            group=group,
+            user=user,
+            metadata=metadata or {},
+            scheduled_at=scheduled_at
+        )
+    
+    @staticmethod
+    def send_sms(
+        to_address: str,
+        message: str,
+        from_address: Optional[str] = None,
+        group=None,
+        user=None,
+        metadata: Optional[Dict[str, Any]] = None,
+        scheduled_at: Optional[timezone.datetime] = None
+    ) -> OutboxMessage:
+        """Send an SMS message"""
+        return MessageSender._send_message(
+            kind=Account.SMS,
+            to_address=to_address,
+            subject=None,
+            message=message,
+            from_address=from_address,
+            group=group,
+            user=user,
+            metadata=metadata or {},
+            scheduled_at=scheduled_at
+        )
+    
+    @staticmethod
+    def send_whatsapp(
+        to_address: str,
+        message: str,
+        from_address: Optional[str] = None,
+        group=None,
+        user=None,
+        metadata: Optional[Dict[str, Any]] = None,
+        scheduled_at: Optional[timezone.datetime] = None
+    ) -> OutboxMessage:
+        """Send a WhatsApp message"""
+        return MessageSender._send_message(
+            kind=Account.WHATSAPP,
+            to_address=to_address,
+            subject=None,
+            message=message,
+            from_address=from_address,
+            group=group,
+            user=user,
+            metadata=metadata or {},
+            scheduled_at=scheduled_at
+        )
+    
+    @staticmethod
+    def send_push(
+        to_address: str,
+        message: str,
+        title: Optional[str] = None,
+        from_address: Optional[str] = None,
+        group=None,
+        user=None,
+        metadata: Optional[Dict[str, Any]] = None,
+        scheduled_at: Optional[timezone.datetime] = None
+    ) -> OutboxMessage:
+        """Send a push notification"""
+        metadata = metadata or {}
+        if title:
+            metadata['title'] = title
+            
+        return MessageSender._send_message(
+            kind=Account.PUSH,
+            to_address=to_address,
+            subject=title,
+            message=message,
+            from_address=from_address,
+            group=group,
+            user=user,
+            metadata=metadata,
+            scheduled_at=scheduled_at
+        )
+    
+    @staticmethod
+    def _send_message(
+        kind: str,
+        to_address: str,
+        message: str,
+        subject: Optional[str] = None,
+        from_address: Optional[str] = None,
+        group=None,
+        user=None,
+        metadata: Optional[Dict[str, Any]] = None,
+        scheduled_at: Optional[timezone.datetime] = None
+    ) -> OutboxMessage:
+        """Internal method to send messages of any kind"""
+        
+        # Find appropriate outbox
+        outbox = OutboxFinder.find_outbox(
+            kind=kind,
+            from_address=from_address,
+            group=group
+        )
+        
+        if not outbox:
+            raise NotificationError(f"No active outbox found for {kind} messages")
+        
+        if not outbox.can_send_messages():
+            raise NotificationError(f"Outbox {outbox} cannot send messages")
+            
+        if not outbox.check_rate_limit():
+            raise NotificationError(f"Outbox {outbox} has exceeded rate limit")
+        
+        # Use outbox address if no from_address specified
+        if not from_address:
+            from_address = outbox.address
+        
+        # Create the outbox message
+        with transaction.atomic():
+            outbox_message = OutboxMessage.objects.create(
+                outbox=outbox,
+                user=user,
+                group=group or outbox.group,
+                to_address=to_address,
+                from_address=from_address,
+                subject=subject,
+                message=message,
+                metadata=metadata or {},
+                scheduled_at=scheduled_at
+            )
+        
+        logger.info(f"Queued {kind} message from {from_address} to {to_address}")
+        return outbox_message
+
+
+class OutboxFinder:
+    """
+    Utility for finding appropriate outboxes for sending messages
+    """
+    
+    @staticmethod
+    def find_outbox(
+        kind: str,
+        from_address: Optional[str] = None,
+        group=None
+    ) -> Optional[Outbox]:
+        """Find the best outbox for sending a message"""
+        
+        query = Outbox.objects.filter(
+            account__kind=kind,
+            account__is_active=True,
+            is_active=True
+        ).select_related('account', 'group')
+        
+        # Prefer outboxes with matching group
+        if group:
+            group_matches = query.filter(group=group)
+            if group_matches.exists():
+                query = group_matches
+        
+        # Prefer outboxes with matching address
+        if from_address:
+            address_matches = query.filter(address=from_address)
+            if address_matches.exists():
+                return address_matches.first()
+        
+        # Return any available outbox
+        return query.first()
+    
+    @staticmethod
+    def get_outboxes_for_account(account: Account) -> List[Outbox]:
+        """Get all active outboxes for an account"""
+        return list(
+            Outbox.objects.filter(
+                account=account,
+                is_active=True
+            ).select_related('group')
+        )
+
+
+class MessageProcessor:
+    """
+    Utility for processing received messages
+    """
+    
+    @staticmethod
+    def process_inbox_message(inbox_message: InboxMessage) -> bool:
+        """Process a received inbox message"""
+        if inbox_message.processed:
+            return True
+            
+        inbox = inbox_message.inbox
+        handler_path = inbox.get_handler()
+        
+        if not handler_path:
+            logger.warning(f"No handler configured for inbox {inbox}")
+            return False
+        
+        try:
+            # Import and call the handler
+            handler_func = _import_handler(handler_path)
+            if handler_func:
+                result = handler_func(inbox_message)
+                inbox_message.mark_processed()
+                logger.info(f"Processed message {inbox_message.id} with handler {handler_path}")
+                return True
+        except Exception as e:
+            logger.error(f"Error processing message {inbox_message.id}: {e}")
+            return False
+        
+        return False
+    
+    @staticmethod
+    def bulk_process_inbox_messages(inbox: Inbox, limit: int = 100) -> int:
+        """Process multiple unprocessed messages for an inbox"""
+        messages = InboxMessage.objects.filter(
+            inbox=inbox,
+            processed=False
+        ).order_by('created')[:limit]
+        
+        processed_count = 0
+        for message in messages:
+            if MessageProcessor.process_inbox_message(message):
+                processed_count += 1
+        
+        return processed_count
+
+
+class BulkNotifier:
+    """
+    Utility for sending bulk notifications
+    """
+    
+    @staticmethod
+    def send_bulk_email(
+        recipients: List[str],
+        subject: str,
+        message: str,
+        from_address: Optional[str] = None,
+        group=None,
+        metadata: Optional[Dict[str, Any]] = None,
+        scheduled_at: Optional[timezone.datetime] = None,
+        batch_size: int = 100
+    ) -> List[OutboxMessage]:
+        """Send bulk email messages"""
+        
+        messages = []
+        for i in range(0, len(recipients), batch_size):
+            batch = recipients[i:i + batch_size]
+            
+            with transaction.atomic():
+                for recipient in batch:
+                    try:
+                        msg = MessageSender.send_email(
+                            to_address=recipient,
+                            subject=subject,
+                            message=message,
+                            from_address=from_address,
+                            group=group,
+                            metadata=metadata,
+                            scheduled_at=scheduled_at
+                        )
+                        messages.append(msg)
+                    except Exception as e:
+                        logger.error(f"Failed to queue email to {recipient}: {e}")
+        
+        return messages
+    
+    @staticmethod
+    def send_bulk_sms(
+        recipients: List[str],
+        message: str,
+        from_address: Optional[str] = None,
+        group=None,
+        metadata: Optional[Dict[str, Any]] = None,
+        scheduled_at: Optional[timezone.datetime] = None,
+        batch_size: int = 100
+    ) -> List[OutboxMessage]:
+        """Send bulk SMS messages"""
+        
+        messages = []
+        for i in range(0, len(recipients), batch_size):
+            batch = recipients[i:i + batch_size]
+            
+            with transaction.atomic():
+                for recipient in batch:
+                    try:
+                        msg = MessageSender.send_sms(
+                            to_address=recipient,
+                            message=message,
+                            from_address=from_address,
+                            group=group,
+                            metadata=metadata,
+                            scheduled_at=scheduled_at
+                        )
+                        messages.append(msg)
+                    except Exception as e:
+                        logger.error(f"Failed to queue SMS to {recipient}: {e}")
+        
+        return messages
+
+
+class MessageStats:
+    """
+    Utility for getting message statistics
+    """
+    
+    @staticmethod
+    def get_outbox_stats(outbox: Outbox) -> Dict[str, Any]:
+        """Get statistics for an outbox"""
+        messages = outbox.messages.all()
+        
+        return {
+            'total_messages': messages.count(),
+            'pending_messages': messages.filter(status=OutboxMessage.PENDING).count(),
+            'sent_messages': messages.filter(status=OutboxMessage.SENT).count(),
+            'failed_messages': messages.filter(status=OutboxMessage.FAILED).count(),
+            'recent_messages': messages.filter(
+                created__gte=timezone.now() - timezone.timedelta(hours=24)
+            ).count(),
+        }
+    
+    @staticmethod
+    def get_inbox_stats(inbox: Inbox) -> Dict[str, Any]:
+        """Get statistics for an inbox"""
+        messages = inbox.messages.all()
+        
+        return {
+            'total_messages': messages.count(),
+            'processed_messages': messages.filter(processed=True).count(),
+            'unprocessed_messages': messages.filter(processed=False).count(),
+            'recent_messages': messages.filter(
+                created__gte=timezone.now() - timezone.timedelta(hours=24)
+            ).count(),
+        }
+
+
+def _import_handler(handler_path: str):
+    """Import a handler function from a module path"""
+    try:
+        module_path, function_name = handler_path.rsplit('.', 1)
+        module = __import__(module_path, fromlist=[function_name])
+        return getattr(module, function_name)
+    except (ImportError, AttributeError, ValueError) as e:
+        logger.error(f"Failed to import handler {handler_path}: {e}")
+        return None
+
+
+# Convenience functions for common operations
+def send_email(to_address: str, subject: str, message: str, **kwargs) -> OutboxMessage:
+    """Convenience function to send an email"""
+    return MessageSender.send_email(to_address, subject, message, **kwargs)
+
+
+def send_sms(to_address: str, message: str, **kwargs) -> OutboxMessage:
+    """Convenience function to send an SMS"""
+    return MessageSender.send_sms(to_address, message, **kwargs)
+
+
+def send_whatsapp(to_address: str, message: str, **kwargs) -> OutboxMessage:
+    """Convenience function to send a WhatsApp message"""
+    return MessageSender.send_whatsapp(to_address, message, **kwargs)
+
+
+def send_push(to_address: str, message: str, title: Optional[str] = None, **kwargs) -> OutboxMessage:
+    """Convenience function to send a push notification"""
+    return MessageSender.send_push(to_address, message, title, **kwargs)