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

mojo/apps/notify/models/inbox.py

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

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

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

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