django-nativemojo 0.1.10__py3-none-any.whl

mojo/apps/notify/models/inbox.py

@@ -0,0 +1,113 @@
+from django.db import models
+from mojo.models import MojoModel
+
+
+class Inbox(models.Model, MojoModel):
+    """
+    Inbox for receiving messages from various notification services
+    """
+    
+    class RestMeta:
+        CAN_SAVE = CAN_CREATE = True
+        CAN_DELETE = True
+        DEFAULT_SORT = "-id"
+        VIEW_PERMS = ["view_notify"]
+        SEARCH_FIELDS = ["address"]
+        SEARCH_TERMS = [
+            "address", 
+            ("account", "account__domain"),
+            ("account_kind", "account__kind"),
+            ("group", "account__group__name")]
+
+        GRAPHS = {
+            "default": {
+                "graphs": {
+                    "account": "basic"
+                }
+            },
+            "list": {
+                "graphs": {
+                    "account": "basic"
+                }
+            }
+        }
+
+    created = models.DateTimeField(auto_now_add=True, editable=False, db_index=True)
+    modified = models.DateTimeField(auto_now=True)
+    
+    account = models.ForeignKey(
+        "notify.Account",
+        related_name="inboxes",
+        on_delete=models.CASCADE,
+        help_text="Notification account this inbox belongs to"
+    )
+    
+    address = models.CharField(
+        max_length=255,
+        db_index=True,
+        help_text="Inbox address (e.g., support@example.com, +1234567890)"
+    )
+    
+    async_handler = models.CharField(
+        max_length=255,
+        null=True,
+        blank=True,
+        default=None,
+        help_text="Python path to async handler function (e.g., app.inbox_handler.on_message_received)"
+    )
+    
+    sync_handler = models.CharField(
+        max_length=255,
+        null=True,
+        blank=True,
+        default=None,
+        help_text="Python path to sync handler function (e.g., app.inbox_handler.on_message_received)"
+    )
+    
+    is_active = models.BooleanField(
+        default=True,
+        help_text="Whether this inbox is active and can receive messages"
+    )
+    
+    settings = models.JSONField(
+        default=dict,
+        blank=True,
+        help_text="Inbox-specific configuration settings"
+    )
+
+    class Meta:
+        unique_together = ['account', 'address']
+        indexes = [
+            models.Index(fields=['account', 'address']),
+            models.Index(fields=['address', 'is_active']),
+        ]
+
+    def __str__(self):
+        return f"{self.account.get_kind_display()} inbox: {self.address}"
+
+    def get_setting(self, key, default=None):
+        """Get a specific setting value"""
+        return self.settings.get(key, default)
+
+    def set_setting(self, key, value):
+        """Set a specific setting value"""
+        self.settings[key] = value
+
+    @property
+    def group(self):
+        """Get the group this inbox belongs to through its account"""
+        return self.account.group if self.account else None
+
+    def can_receive_messages(self):
+        """Check if this inbox can receive messages"""
+        return self.is_active and self.account.is_active
+
+    def get_handler(self, async_preferred=True):
+        """Get the appropriate handler for message processing"""
+        if async_preferred and self.async_handler:
+            return self.async_handler
+        elif self.sync_handler:
+            return self.sync_handler
+        elif self.async_handler:
+            return self.async_handler
+        return None

mojo/apps/notify/models/inbox_message.py

@@ -0,0 +1,173 @@
+from django.db import models
+from mojo.models import MojoModel
+
+
+class InboxMessage(models.Model, MojoModel):
+    """
+    Message received in an inbox from various notification services
+    """
+    
+    class RestMeta:
+        CAN_SAVE = CAN_CREATE = True
+        CAN_DELETE = True
+        DEFAULT_SORT = "-id"
+        VIEW_PERMS = ["view_notify"]
+        SEARCH_FIELDS = ["to_address", "from_address", "subject", "message"]
+        SEARCH_TERMS = [
+            "to_address", "from_address", "subject",
+            ("inbox", "inbox__address"),
+            ("account", "inbox__account__domain"),
+            ("account_kind", "inbox__account__kind"),
+            ("user", "user__username"),
+            ("group", "group__name")]
+
+        GRAPHS = {
+            "default": {
+                "graphs": {
+                    "inbox": "basic",
+                    "user": "basic",
+                    "group": "basic"
+                }
+            },
+            "list": {
+                "graphs": {
+                    "inbox": "basic",
+                    "user": "basic",
+                    "group": "basic"
+                }
+            }
+        }
+
+    created = models.DateTimeField(auto_now_add=True, editable=False, db_index=True)
+    modified = models.DateTimeField(auto_now=True)
+    
+    inbox = models.ForeignKey(
+        "notify.Inbox",
+        related_name="messages",
+        on_delete=models.CASCADE,
+        help_text="Inbox that received this message"
+    )
+    
+    user = models.ForeignKey(
+        "account.User",
+        related_name="inbox_messages",
+        null=True,
+        blank=True,
+        default=None,
+        on_delete=models.CASCADE,
+        help_text="User associated with this message (if applicable)"
+    )
+    
+    group = models.ForeignKey(
+        "account.Group",
+        related_name="inbox_messages",
+        null=True,
+        blank=True,
+        default=None,
+        on_delete=models.CASCADE,
+        help_text="Group associated with this message (if applicable)"
+    )
+    
+    to_address = models.CharField(
+        max_length=255,
+        db_index=True,
+        help_text="Recipient address (e.g., inbox@example.com, +1234567890)"
+    )
+    
+    from_address = models.CharField(
+        max_length=255,
+        db_index=True,
+        help_text="Sender address (e.g., sender@example.com, +0987654321)"
+    )
+    
+    subject = models.CharField(
+        max_length=500,
+        null=True,
+        blank=True,
+        default=None,
+        help_text="Message subject (for email, etc.)"
+    )
+    
+    message = models.TextField(
+        help_text="Message content/body"
+    )
+    
+    metadata = models.JSONField(
+        default=dict,
+        blank=True,
+        help_text="Additional message metadata (headers, delivery info, etc.)"
+    )
+    
+    processed = models.BooleanField(
+        default=False,
+        db_index=True,
+        help_text="Whether this message has been processed by handlers"
+    )
+    
+    processed_at = models.DateTimeField(
+        null=True,
+        blank=True,
+        default=None,
+        help_text="When this message was processed"
+    )
+    
+    message_id = models.CharField(
+        max_length=255,
+        null=True,
+        blank=True,
+        default=None,
+        db_index=True,
+        help_text="External message ID from the service provider"
+    )
+
+    class Meta:
+        indexes = [
+            models.Index(fields=['inbox', 'created']),
+            models.Index(fields=['from_address', 'created']),
+            models.Index(fields=['to_address', 'created']),
+            models.Index(fields=['processed', 'created']),
+            models.Index(fields=['user', 'created']),
+            models.Index(fields=['group', 'created']),
+        ]
+
+    def __str__(self):
+        subject_preview = f" - {self.subject[:50]}..." if self.subject else ""
+        return f"{self.inbox.account.get_kind_display()} message: {self.from_address} → {self.to_address}{subject_preview}"
+
+    def get_metadata_value(self, key, default=None):
+        """Get a specific metadata value"""
+        return self.metadata.get(key, default)
+
+    def set_metadata_value(self, key, value):
+        """Set a specific metadata value"""
+        self.metadata[key] = value
+
+    @property
+    def account(self):
+        """Get the account this message was received through"""
+        return self.inbox.account if self.inbox else None
+
+    @property
+    def message_kind(self):
+        """Get the kind of message (email, sms, etc.)"""
+        return self.account.kind if self.account else None
+
+    @property
+    def message_preview(self):
+        """Get a preview of the message content"""
+        if not self.message:
+            return ""
+        return self.message[:200] + "..." if len(self.message) > 200 else self.message
+
+    def mark_processed(self):
+        """Mark this message as processed"""
+        from django.utils import timezone
+        self.processed = True
+        self.processed_at = timezone.now()
+        self.save(update_fields=['processed', 'processed_at'])
+
+    def is_from_user(self, user):
+        """Check if this message is from a specific user"""
+        if not user or not user.email:
+            return False
+        return self.from_address.lower() == user.email.lower()

mojo/apps/notify/models/outbox.py

@@ -0,0 +1,129 @@
+from django.db import models
+from mojo.models import MojoModel
+
+
+class Outbox(models.Model, MojoModel):
+    """
+    Outbox for sending messages through various notification services
+    """
+    
+    class RestMeta:
+        CAN_SAVE = CAN_CREATE = True
+        CAN_DELETE = True
+        DEFAULT_SORT = "-id"
+        VIEW_PERMS = ["view_notify"]
+        SEARCH_FIELDS = ["address"]
+        SEARCH_TERMS = [
+            "address", 
+            ("account", "account__domain"),
+            ("account_kind", "account__kind"),
+            ("group", "group__name")]
+
+        GRAPHS = {
+            "default": {
+                "graphs": {
+                    "account": "basic",
+                    "group": "basic"
+                }
+            },
+            "list": {
+                "graphs": {
+                    "account": "basic",
+                    "group": "basic"
+                }
+            }
+        }
+
+    created = models.DateTimeField(auto_now_add=True, editable=False, db_index=True)
+    modified = models.DateTimeField(auto_now=True)
+    
+    account = models.ForeignKey(
+        "notify.Account",
+        related_name="outboxes",
+        on_delete=models.CASCADE,
+        help_text="Notification account this outbox belongs to"
+    )
+    
+    group = models.ForeignKey(
+        "account.Group",
+        related_name="outboxes",
+        null=True,
+        blank=True,
+        default=None,
+        on_delete=models.CASCADE,
+        help_text="Group that owns this outbox"
+    )
+    
+    address = models.CharField(
+        max_length=255,
+        db_index=True,
+        help_text="Outbox address (e.g., outbox@example.com, +1234567890)"
+    )
+    
+    handler = models.CharField(
+        max_length=255,
+        null=True,
+        blank=True,
+        default=None,
+        help_text="Python path to handler function (e.g., app.outbox_handler.on_message_sent)"
+    )
+    
+    is_active = models.BooleanField(
+        default=True,
+        help_text="Whether this outbox is active and can send messages"
+    )
+    
+    settings = models.JSONField(
+        default=dict,
+        blank=True,
+        help_text="Outbox-specific configuration settings"
+    )
+    
+    rate_limit = models.IntegerField(
+        null=True,
+        blank=True,
+        default=None,
+        help_text="Max messages per hour (null for no limit)"
+    )
+
+    class Meta:
+        unique_together = ['account', 'address']
+        indexes = [
+            models.Index(fields=['account', 'address']),
+            models.Index(fields=['group', 'is_active']),
+            models.Index(fields=['address', 'is_active']),
+        ]
+
+    def __str__(self):
+        group_name = self.group.name if self.group else "No Group"
+        return f"{self.account.get_kind_display()} outbox: {self.address} ({group_name})"
+
+    def get_setting(self, key, default=None):
+        """Get a specific setting value"""
+        return self.settings.get(key, default)
+
+    def set_setting(self, key, value):
+        """Set a specific setting value"""
+        self.settings[key] = value
+
+    def can_send_messages(self):
+        """Check if this outbox can send messages"""
+        return self.is_active and self.account.is_active
+
+    def check_rate_limit(self):
+        """Check if outbox is within rate limits"""
+        if not self.rate_limit:
+            return True
+            
+        from django.utils import timezone
+        from datetime import timedelta
+        
+        one_hour_ago = timezone.now() - timedelta(hours=1)
+        recent_messages = self.messages.filter(created__gte=one_hour_ago).count()
+        
+        return recent_messages < self.rate_limit
+
+    @property
+    def message_kind(self):
+        """Get the kind of messages this outbox sends"""
+        return self.account.kind if self.account else None

mojo/apps/notify/models/outbox_message.py

@@ -0,0 +1,288 @@
+from django.db import models
+from mojo.models import MojoModel
+
+
+class OutboxMessage(models.Model, MojoModel):
+    """
+    Message to be sent or already sent through an outbox
+    """
+    
+    class RestMeta:
+        CAN_SAVE = CAN_CREATE = True
+        CAN_DELETE = True
+        DEFAULT_SORT = "-id"
+        VIEW_PERMS = ["view_notify"]
+        SEARCH_FIELDS = ["to_address", "from_address", "subject", "message"]
+        SEARCH_TERMS = [
+            "to_address", "from_address", "subject", "status",
+            ("outbox", "outbox__address"),
+            ("account", "outbox__account__domain"),
+            ("account_kind", "outbox__account__kind"),
+            ("user", "user__username"),
+            ("group", "group__name")]
+
+        GRAPHS = {
+            "default": {
+                "graphs": {
+                    "outbox": "basic",
+                    "user": "basic",
+                    "group": "basic"
+                }
+            },
+            "list": {
+                "graphs": {
+                    "outbox": "basic",
+                    "user": "basic",
+                    "group": "basic"
+                }
+            }
+        }
+
+    # Message status choices
+    PENDING = 'pending'
+    SENDING = 'sending'
+    SENT = 'sent'
+    FAILED = 'failed'
+    CANCELLED = 'cancelled'
+    
+    STATUS_CHOICES = [
+        (PENDING, 'Pending'),
+        (SENDING, 'Sending'),
+        (SENT, 'Sent'),
+        (FAILED, 'Failed'),
+        (CANCELLED, 'Cancelled'),
+    ]
+
+    created = models.DateTimeField(auto_now_add=True, editable=False, db_index=True)
+    modified = models.DateTimeField(auto_now=True)
+    
+    outbox = models.ForeignKey(
+        "notify.Outbox",
+        related_name="messages",
+        on_delete=models.CASCADE,
+        help_text="Outbox that will send this message"
+    )
+    
+    user = models.ForeignKey(
+        "account.User",
+        related_name="outbox_messages",
+        null=True,
+        blank=True,
+        default=None,
+        on_delete=models.CASCADE,
+        help_text="User associated with this message (if applicable)"
+    )
+    
+    group = models.ForeignKey(
+        "account.Group",
+        related_name="outbox_messages",
+        null=True,
+        blank=True,
+        default=None,
+        on_delete=models.CASCADE,
+        help_text="Group associated with this message (if applicable)"
+    )
+    
+    to_address = models.CharField(
+        max_length=255,
+        db_index=True,
+        help_text="Recipient address (e.g., joe@example.com, +1234567890)"
+    )
+    
+    from_address = models.CharField(
+        max_length=255,
+        db_index=True,
+        help_text="Sender address (e.g., outbox@example.com, +0987654321)"
+    )
+    
+    subject = models.CharField(
+        max_length=500,
+        null=True,
+        blank=True,
+        default=None,
+        help_text="Message subject (for email, etc.)"
+    )
+    
+    message = models.TextField(
+        help_text="Message content/body"
+    )
+    
+    metadata = models.JSONField(
+        default=dict,
+        blank=True,
+        help_text="Additional message metadata (delivery options, attachments, etc.)"
+    )
+    
+    status = models.CharField(
+        max_length=32,
+        choices=STATUS_CHOICES,
+        default=PENDING,
+        db_index=True,
+        help_text="Current status of the message"
+    )
+    
+    scheduled_at = models.DateTimeField(
+        null=True,
+        blank=True,
+        default=None,
+        db_index=True,
+        help_text="When this message should be sent (null for immediate)"
+    )
+    
+    sent_at = models.DateTimeField(
+        null=True,
+        blank=True,
+        default=None,
+        help_text="When this message was actually sent"
+    )
+    
+    failed_at = models.DateTimeField(
+        null=True,
+        blank=True,
+        default=None,
+        help_text="When this message failed to send"
+    )
+    
+    error_message = models.TextField(
+        null=True,
+        blank=True,
+        default=None,
+        help_text="Error message if sending failed"
+    )
+    
+    message_id = models.CharField(
+        max_length=255,
+        null=True,
+        blank=True,
+        default=None,
+        db_index=True,
+        help_text="External message ID from the service provider"
+    )
+    
+    retry_count = models.IntegerField(
+        default=0,
+        help_text="Number of times sending has been attempted"
+    )
+    
+    max_retries = models.IntegerField(
+        default=3,
+        help_text="Maximum number of retry attempts"
+    )
+
+    class Meta:
+        indexes = [
+            models.Index(fields=['outbox', 'status', 'created']),
+            models.Index(fields=['status', 'scheduled_at']),
+            models.Index(fields=['to_address', 'created']),
+            models.Index(fields=['from_address', 'created']),
+            models.Index(fields=['user', 'created']),
+            models.Index(fields=['group', 'created']),
+            models.Index(fields=['sent_at']),
+        ]
+
+    def __str__(self):
+        subject_preview = f" - {self.subject[:50]}..." if self.subject else ""
+        return f"{self.outbox.account.get_kind_display()} message: {self.from_address} → {self.to_address}{subject_preview} ({self.get_status_display()})"
+
+    def get_metadata_value(self, key, default=None):
+        """Get a specific metadata value"""
+        return self.metadata.get(key, default)
+
+    def set_metadata_value(self, key, value):
+        """Set a specific metadata value"""
+        self.metadata[key] = value
+
+    @property
+    def account(self):
+        """Get the account this message will be sent through"""
+        return self.outbox.account if self.outbox else None
+
+    @property
+    def message_kind(self):
+        """Get the kind of message (email, sms, etc.)"""
+        return self.account.kind if self.account else None
+
+    @property
+    def message_preview(self):
+        """Get a preview of the message content"""
+        if not self.message:
+            return ""
+        return self.message[:200] + "..." if len(self.message) > 200 else self.message
+
+    @property
+    def is_pending(self):
+        return self.status == self.PENDING
+
+    @property
+    def is_sending(self):
+        return self.status == self.SENDING
+
+    @property
+    def is_sent(self):
+        return self.status == self.SENT
+
+    @property
+    def is_failed(self):
+        return self.status == self.FAILED
+
+    @property
+    def is_cancelled(self):
+        return self.status == self.CANCELLED
+
+    @property
+    def can_retry(self):
+        """Check if this message can be retried"""
+        return self.is_failed and self.retry_count < self.max_retries
+
+    @property
+    def is_ready_to_send(self):
+        """Check if this message is ready to be sent"""
+        if not self.is_pending:
+            return False
+        
+        if self.scheduled_at:
+            from django.utils import timezone
+            return timezone.now() >= self.scheduled_at
+        
+        return True
+
+    def mark_sending(self):
+        """Mark this message as currently being sent"""
+        self.status = self.SENDING
+        self.save(update_fields=['status'])
+
+    def mark_sent(self, message_id=None):
+        """Mark this message as successfully sent"""
+        from django.utils import timezone
+        self.status = self.SENT
+        self.sent_at = timezone.now()
+        if message_id:
+            self.message_id = message_id
+        self.save(update_fields=['status', 'sent_at', 'message_id'])
+
+    def mark_failed(self, error_message=None):
+        """Mark this message as failed to send"""
+        from django.utils import timezone
+        self.status = self.FAILED
+        self.failed_at = timezone.now()
+        self.retry_count += 1
+        if error_message:
+            self.error_message = error_message
+        self.save(update_fields=['status', 'failed_at', 'retry_count', 'error_message'])
+
+    def mark_cancelled(self):
+        """Mark this message as cancelled"""
+        self.status = self.CANCELLED
+        self.save(update_fields=['status'])
+
+    def reset_for_retry(self):
+        """Reset message status for retry"""
+        if self.can_retry:
+            self.status = self.PENDING
+            self.save(update_fields=['status'])
+
+    def is_to_user(self, user):
+        """Check if this message is to a specific user"""
+        if not user or not user.email:
+            return False
+        return self.to_address.lower() == user.email.lower()