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

mojo/apps/notify/models/template.py

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

@@ -1,73 +0,0 @@
-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="hours")
-        return True
-    except Exception as err:
-        if EMAIL_METRICS:
-            metrics.record("email_errors", category="email", min_granularity="hours")
-        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

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

mojo/apps/notify/utils/notifications.py

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