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

mojo/apps/account/models/group.py

@@ -1,6 +1,6 @@
 from django.db import models
 from mojo.models import MojoModel, MojoSecrets
-from mojo.helpers import dates
+from mojo.helpers import dates, logit
 from mojo.apps import metrics
 from mojo.helpers.settings import settings
 
@@ -27,7 +27,11 @@ class Group(MojoSecrets, MojoModel):
     # JSON-based metadata field
     metadata = models.JSONField(default=dict, blank=True)
 
+    avatar = models.ForeignKey('fileman.File', on_delete=models.SET_NULL,
+        null=True, blank=True, related_name='+')
+
     class RestMeta:
+        LOG_CHANGES = True
         SEARCH_FIELDS = ["name"]
         VIEW_PERMS = ["view_groups", "manage_groups"]
         SAVE_PERMS = ["manage_groups"]
@@ -44,7 +48,10 @@ class Group(MojoSecrets, MojoModel):
                     'last_activity',
                     'is_active',
                     'kind',
-                ]
+                ],
+                "graphs": {
+                    "avatar": "basic"
+                }
             },
             "default": {
                 "fields": [
@@ -59,11 +66,27 @@ class Group(MojoSecrets, MojoModel):
                     'metadata'
                 ],
                 "graphs": {
+                    "avatar": "basic",
                     "parent": "basic"
                 }
             },
 
         }
+        FORMATS = {
+            "csv": [
+                "id",
+                "uuid",
+                "name",
+                "created",
+                "modified",
+                "last_activity",
+                "is_active",
+                "kind",
+                "parent.id",
+                "parent.name",
+                ("metadata.timezone", "timezone")
+            ]
+        }
 
     @property
     def timezone(self):
@@ -78,14 +101,10 @@ class Group(MojoSecrets, MojoModel):
     def __str__(self):
         return str(self.name)
 
-    def has_permission(self, user):
-        from mojo.account.models.member import GroupMember
-        return GroupMember.objects.filter(user=user).last()
-
-    def member_has_permission(self, user, perms, check_user=True):
+    def user_has_permission(self, user, perms, check_user=True):
         if check_user and user.has_permission(perms):
             return True
-        ms = self.has_permission(user)
+        ms = self.get_member_for_user(user)
         if ms is not None:
             return ms.has_permission(perms)
         return False
@@ -103,9 +122,276 @@ class Group(MojoSecrets, MojoModel):
         self.metadata = self.jsonfield_as_objict("metadata")
         return self.metadata
 
+    def add_member(self, user):
+        member, created = self.members.get_or_create(user=user)
+        return member
+
     def get_member_for_user(self, user):
         return self.members.filter(user=user).last()
 
+    def get_children(self, is_active=True, kind=None):
+        """
+        Returns a QuerySet of all direct and indirect children of this group.
+        """
+        child_ids = self._get_all_child_ids()
+        queryset = Group.objects.filter(id__in=child_ids)
+
+        if is_active is not None:
+            queryset = queryset.filter(is_active=is_active)
+        if kind:
+            queryset = queryset.filter(kind=kind)
+
+        return queryset
+
+    def _get_all_child_ids(self, collected_ids=None):
+        """
+        Recursively collects the IDs of all children.
+        """
+        if collected_ids is None:
+            collected_ids = set()
+
+        # Note: self.groups is the related_name from the parent ForeignKey
+        children = self.groups.all()
+        for child in children:
+            if child.id not in collected_ids:
+                collected_ids.add(child.id)
+                child._get_all_child_ids(collected_ids)
+        return list(collected_ids)
+
+    def get_parents(self, is_active=True, kind=None):
+        """
+        Returns a QuerySet of all parents (ancestors) of this group.
+        """
+        parent_ids = []
+        current = self.parent
+        while current:
+            parent_ids.append(current.id)
+            current = current.parent
+
+        queryset = Group.objects.filter(id__in=parent_ids)
+
+        if is_active is not None:
+            queryset = queryset.filter(is_active=is_active)
+        if kind:
+            queryset = queryset.filter(kind=kind)
+
+        return queryset
+
+    @property
+    def top_most_parent(self):
+        """
+        Finds the top-most parent (root ancestor) of this group.
+        Returns self if the group has no parent.
+        """
+        current = self
+        while current.parent:
+            current = current.parent
+        return current
+
+    def is_child_of(self, parent_group):
+        """
+        Checks if this group is a descendant of the given parent_group.
+        """
+        current = self.parent
+        while current:
+            if current.id == parent_group.id:
+                return True
+            current = current.parent
+        return False
+
+    def is_parent_of(self, child_group):
+        """
+        Checks if this group is an ancestor of the given child_group.
+        """
+        return child_group.is_child_of(self)
+
+    def invite(self, email, context=None):
+        """
+        Invites a user to join the group.
+        """
+        from mojo.apps.account.models import User
+        user = User.objects.filter(email=email).last()
+        ms = None
+        if context is None:
+            context = {}
+        context['group'] = self
+        if user:
+            ms = self.add_member(user)
+        elif not user:
+            user = User(is_active=True)
+            user.on_rest_pre_save(dict(email=None), True)
+            user.save()
+            ms = self.add_member(user)
+        try:
+            user.send_template_email('group_invite', context)
+        except Exception as e:
+            logit.error(f"Error sending email: {e}")
+        return ms
+
+    def push_notification(self, title=None, body=None, data=None, **kwargs):
+        from mojo.apps.account.services.push import send_direct_notification
+        for member in self.members.filter(is_active=True):
+            send_direct_notification(member.user, title=title, body=body, data=data, **kwargs)
+
+    def send_email(
+        self,
+        to,
+        subject=None,
+        body_text=None,
+        body_html=None,
+        cc=None,
+        bcc=None,
+        reply_to=None,
+        **kwargs
+    ):
+        """Send email using mailbox determined by group's domain or system default
+
+        Args:
+            to: One or more recipient addresses
+            subject: Email subject
+            body_text: Optional plain text body
+            body_html: Optional HTML body
+            cc, bcc, reply_to: Optional addressing
+            **kwargs: Additional arguments passed to mailbox.send_email()
+
+        Returns:
+            SentMessage instance
+
+        Raises:
+            ValueError: If no mailbox can be found
+        """
+        from mojo.apps.aws.models import Mailbox
+
+        mailbox = None
+        domain = None
+
+        # Try to get domain from this group's metadata
+        if self.metadata:
+            domain = self.metadata.get("domain")
+
+        # If no domain, check top_most_parent's metadata
+        if not domain and self.top_most_parent != self:
+            parent_metadata = self.top_most_parent.metadata
+            if parent_metadata:
+                domain = parent_metadata.get("domain")
+
+        # Try to get mailbox from domain
+        if domain:
+            # Try domain default first
+            mailbox = Mailbox.get_domain_default(domain)
+            if not mailbox:
+                # Try any mailbox from that domain
+                mailbox = Mailbox.objects.filter(
+                    domain__name__iexact=domain,
+                    allow_outbound=True
+                ).first()
+
+        # Fall back to system default
+        if not mailbox:
+            mailbox = Mailbox.get_system_default()
+
+        if not mailbox:
+            raise ValueError("No mailbox available for sending email. Please configure a system default mailbox.")
+
+        return mailbox.send_email(
+            to=to,
+            subject=subject,
+            body_text=body_text,
+            body_html=body_html,
+            cc=cc,
+            bcc=bcc,
+            reply_to=reply_to,
+            **kwargs
+        )
+
+    def send_template_email(
+        self,
+        to,
+        template_name,
+        context=None,
+        cc=None,
+        bcc=None,
+        reply_to=None,
+        **kwargs
+    ):
+        """Send template email using mailbox determined by group's domain or system default
+
+        Args:
+            to: One or more recipient addresses
+            template_name: Name of the EmailTemplate in database
+            context: Template context variables (group will be added automatically)
+            cc, bcc, reply_to: Optional addressing
+            **kwargs: Additional arguments passed to mailbox.send_template_email()
+
+        Returns:
+            SentMessage instance
+
+        Raises:
+            ValueError: If no mailbox can be found or template not found
+        """
+        from mojo.apps.aws.models import Mailbox
+
+        mailbox = None
+        domain = None
+
+        # Try to get domain from this group's metadata
+        if self.metadata:
+            domain = self.metadata.get("domain")
+
+        # If no domain, check top_most_parent's metadata
+        if not domain and self.top_most_parent != self:
+            parent_metadata = self.top_most_parent.metadata
+            if parent_metadata:
+                domain = parent_metadata.get("domain")
+
+        # Try to get mailbox from domain
+        if domain:
+            # Try domain default first
+            mailbox = Mailbox.get_domain_default(domain)
+            if not mailbox:
+                # Try any mailbox from that domain
+                mailbox = Mailbox.objects.filter(
+                    domain__name__iexact=domain,
+                    allow_outbound=True
+                ).first()
+
+        # Fall back to system default
+        if not mailbox:
+            mailbox = Mailbox.get_system_default()
+
+        if not mailbox:
+            raise ValueError("No mailbox available for sending email. Please configure a system default mailbox.")
+
+        # Add group to context if not already present
+        if context is None:
+            context = {}
+        if 'group' not in context:
+            context['group'] = self
+
+        return mailbox.send_template_email(
+            to=to,
+            template_name=template_name,
+            context=context,
+            cc=cc,
+            bcc=bcc,
+            reply_to=reply_to,
+            **kwargs
+        )
+
+    def check_view_permission(self, perms, request):
+        # check if the user is a member of the group
+        if request.user.has_permission(perms):
+            return True
+        ms = self.get_member_for_user(request.user)
+        if ms is None:
+            return False
+        if ms.has_permission(["view_group", "manage_group"]):
+            return True
+        # we still allow the user to view the group if they are a member
+        # but we limit the fields they can see
+        request.DATA.set("graph", "basic")
+        return True
+
     @classmethod
     def on_rest_handle_list(cls, request):
         if cls.rest_check_permission(request, "VIEW_PERMS"):

mojo/apps/account/models/member.py

@@ -27,6 +27,7 @@ class GroupMember(models.Model, MojoModel):
     class RestMeta:
         VIEW_PERMS = ["view_groups", "manage_groups"]
         SAVE_PERMS = ["manage_groups"]
+        CREATED_BY_OWNER_FIELD = 'created_by'  # we do this to protect user
         LIST_DEFAULT_FILTERS = {
             "is_active": True
         }
@@ -41,7 +42,7 @@ class GroupMember(models.Model, MojoModel):
                     'metadata'
                 ],
                 "graphs": {
-                    "user": "basic",
+                    "user": "default",
                     "group": "basic"
                 }
             }
@@ -50,6 +51,18 @@ class GroupMember(models.Model, MojoModel):
     def __str__(self):
         return f"{self.user.username}@{self.group.name}"
 
+    @property
+    def username(self):
+        return self.user.username
+
+    @property
+    def display_name(self):
+        return self.user.display_name
+
+    @property
+    def email(self):
+        return self.user.email
+
     def can_change_permission(self, perm, value, request):
         if request.user.has_permission(["manage_groups", "manage_users"]):
             return True

mojo/apps/account/models/push/__init__.py

@@ -0,0 +1,4 @@
+from .delivery import NotificationDelivery
+from .template import NotificationTemplate
+from .config import PushConfig
+from .device import RegisteredDevice

mojo/apps/account/models/push/config.py

@@ -0,0 +1,112 @@
+from django.db import models
+from mojo.models import MojoModel, MojoSecrets
+
+
+class PushConfig(MojoSecrets, MojoModel):
+    """
+    Push notification configuration. Can be system-wide (group=None) or org-specific.
+    Sensitive credentials are encrypted via MojoSecrets.
+
+    FCM is the primary service supporting both iOS and Android devices.
+    APNS is available for iOS-specific requirements but rarely needed.
+    Test mode allows fake notifications for development and testing.
+    """
+    created = models.DateTimeField(auto_now_add=True, editable=False, db_index=True)
+    modified = models.DateTimeField(auto_now=True, db_index=True)
+
+    group = models.OneToOneField("account.Group", on_delete=models.CASCADE,
+                                related_name="push_config", null=True, blank=True,
+                                help_text="Organization for this config. Null = system default")
+
+    name = models.CharField(max_length=100, help_text="Configuration name")
+    is_active = models.BooleanField(default=True, db_index=True)
+
+    # Test/Development Mode
+    test_mode = models.BooleanField(default=False, db_index=True,
+                                   help_text="Enable test mode - fake notifications for development")
+
+    # FCM Configuration (Primary - supports both iOS and Android)
+    # APNS Configuration (iOS-specific, rarely needed - use FCM instead)
+    apns_enabled = models.BooleanField(default=False,
+                                      help_text="APNS for iOS-specific needs. FCM is preferred.")
+    apns_key_id = models.CharField(max_length=100, blank=True)
+    apns_team_id = models.CharField(max_length=100, blank=True)
+    apns_bundle_id = models.CharField(max_length=255, blank=True)
+    apns_use_sandbox = models.BooleanField(default=False)
+
+    # FCM Configuration (Primary - supports both iOS and Android)
+    fcm_enabled = models.BooleanField(default=True,
+                                     help_text="FCM handles both iOS and Android notifications")
+    fcm_sender_id = models.CharField(max_length=100, blank=True)
+
+    # General Settings
+    default_sound = models.CharField(max_length=50, default="default")
+    default_badge_count = models.IntegerField(default=1)
+
+    class Meta:
+        ordering = ['group__name', 'name']
+
+    class RestMeta:
+        VIEW_PERMS = ["manage_push_config", "manage_groups"]
+        SAVE_PERMS = ["manage_push_config", "manage_groups"]
+        SEARCH_FIELDS = ["name"]
+        LIST_DEFAULT_FILTERS = {"is_active": True}
+        GRAPHS = {
+            "basic": {
+                "fields": ["id", "name", "fcm_enabled", "apns_enabled", "test_mode", "default_sound", "is_active"]
+            },
+            "default": {
+                "exclude": ["mojo_secrets"],  # Never expose encrypted secrets
+                "graphs": {
+                    "group": "basic"
+                }
+            },
+            "full": {
+                "exclude": ["mojo_secrets"],  # Never expose encrypted secrets
+                "graphs": {
+                    "group": "default"
+                }
+            }
+        }
+
+    def __str__(self):
+        org = self.group.name if self.group else "System Default"
+        return f"{self.name} ({org})"
+
+    @classmethod
+    def get_for_user(cls, user):
+        """
+        Get push config for user. Priority: user's org config -> system default
+        """
+        if user.org:
+            config = cls.objects.filter(group=user.org, is_active=True).first()
+            if config:
+                return config
+
+        # Fallback to system default
+        return cls.objects.filter(group__isnull=True, is_active=True).first()
+
+    def set_apns_key_file(self, key_content):
+        """Set APNS private key file content (will be encrypted)."""
+        self.set_secret('apns_key_file', key_content)
+
+    def get_apns_key_file(self):
+        """Get decrypted APNS private key file content."""
+        return self.get_secret('apns_key_file', '')
+
+    def set_fcm_server_key(self, server_key):
+        """Set FCM server key (will be encrypted)."""
+        self.set_secret('fcm_server_key', server_key)
+
+    def get_fcm_server_key(self):
+        """Get decrypted FCM server key."""
+        return self.get_secret('fcm_server_key', '')
+
+    # Backwards compatibility aliases
+    def get_decrypted_apns_key(self):
+        """Get decrypted APNS key file content."""
+        return self.get_apns_key_file()
+
+    def get_decrypted_fcm_key(self):
+        """Get decrypted FCM server key."""
+        return self.get_fcm_server_key()

mojo/apps/account/models/push/delivery.py

@@ -0,0 +1,93 @@
+from django.db import models
+from mojo.models import MojoModel
+
+
+class NotificationDelivery(models.Model, MojoModel):
+    """
+    Track all push notification delivery attempts and results.
+    """
+    created = models.DateTimeField(auto_now_add=True, editable=False, db_index=True)
+    modified = models.DateTimeField(auto_now=True, db_index=True)
+
+    user = models.ForeignKey("account.User", on_delete=models.CASCADE,
+                           related_name="notification_deliveries")
+    device = models.ForeignKey("account.RegisteredDevice", on_delete=models.CASCADE,
+                             related_name="notification_deliveries")
+    template = models.ForeignKey("account.NotificationTemplate", on_delete=models.SET_NULL,
+                               null=True, blank=True, related_name="deliveries")
+
+    title = models.CharField(max_length=200, blank=True, null=True)
+    body = models.TextField(blank=True, null=True)
+    category = models.CharField(max_length=50, db_index=True)
+    action_url = models.URLField(blank=True, null=True)
+    data_payload = models.JSONField(default=dict, blank=True,
+                                   help_text="Custom data payload sent with notification")
+
+    # Delivery tracking
+    status = models.CharField(max_length=20, choices=[
+        ('pending', 'Pending'),
+        ('sent', 'Sent'),
+        ('delivered', 'Delivered'),
+        ('failed', 'Failed')
+    ], default='pending', db_index=True)
+
+    sent_at = models.DateTimeField(null=True, blank=True, db_index=True)
+    delivered_at = models.DateTimeField(null=True, blank=True)
+    error_message = models.TextField(blank=True, null=True)
+
+    # Push service specific data
+    platform_data = models.JSONField(default=dict, blank=True,
+                                    help_text="Platform-specific response data")
+
+    class Meta:
+        ordering = ['-created']
+
+    class RestMeta:
+        VIEW_PERMS = ["view_notifications", "manage_notifications", "owner", "manage_users"]
+        SAVE_PERMS = ["manage_notifications"]
+        SEARCH_FIELDS = ["title", "category"]
+        LIST_DEFAULT_FILTERS = {"status": "sent"}
+        GRAPHS = {
+            "basic": {
+                "fields": ["id", "title", "category", "status", "sent_at", "created"]
+            },
+            "default": {
+                "fields": ["id", "title", "body", "category", "action_url", "data_payload", "status",
+                          "sent_at", "delivered_at", "error_message", "created"],
+                "graphs": {
+                    "user": "basic",
+                    "device": "basic"
+                }
+            },
+            "full": {
+                "graphs": {
+                    "user": "default",
+                    "device": "default",
+                    "template": "basic"
+                }
+            }
+        }
+
+    def __str__(self):
+        display_title = self.title or f"[{self.category} data]"
+        return f"{display_title} -> {self.device} ({self.status})"
+
+    def mark_sent(self):
+        """Mark notification as sent with timestamp."""
+        from mojo.helpers import dates
+        self.status = 'sent'
+        self.sent_at = dates.utcnow()
+        self.save(update_fields=['status', 'sent_at'])
+
+    def mark_delivered(self):
+        """Mark notification as delivered with timestamp."""
+        from mojo.helpers import dates
+        self.status = 'delivered'
+        self.delivered_at = dates.utcnow()
+        self.save(update_fields=['status', 'delivered_at'])
+
+    def mark_failed(self, error_message):
+        """Mark notification as failed with error message."""
+        self.status = 'failed'
+        self.error_message = error_message
+        self.save(update_fields=['status', 'error_message'])

mojo/apps/account/models/push/device.py

@@ -0,0 +1,66 @@
+from django.db import models
+from mojo.models import MojoModel
+
+
+class RegisteredDevice(models.Model, MojoModel):
+    """
+    Represents a device explicitly registered for push notifications via REST API.
+    Separate from UserDevice which tracks browser sessions via duid/user-agent.
+    """
+    created = models.DateTimeField(auto_now_add=True, editable=False, db_index=True)
+    modified = models.DateTimeField(auto_now=True, db_index=True)
+
+    user = models.ForeignKey("account.User", on_delete=models.CASCADE, related_name='registered_devices')
+
+    # Device identification
+    device_token = models.TextField(db_index=True, help_text="Push token from platform")
+    device_id = models.CharField(max_length=255, db_index=True, help_text="App-provided device ID")
+    platform = models.CharField(max_length=20, choices=[
+        ('ios', 'iOS'),
+        ('android', 'Android'),
+        ('web', 'Web')
+    ], db_index=True)
+
+    # Device info
+    app_version = models.CharField(max_length=50, blank=True)
+    os_version = models.CharField(max_length=50, blank=True)
+    device_name = models.CharField(max_length=100, blank=True)
+
+    # Push preferences
+    push_enabled = models.BooleanField(default=True, db_index=True)
+    push_preferences = models.JSONField(default=dict, blank=True,
+                                      help_text="Category-based notification preferences")
+
+    # Status tracking
+    is_active = models.BooleanField(default=True, db_index=True)
+    last_seen = models.DateTimeField(auto_now=True)
+
+    class Meta:
+        unique_together = [('user', 'device_id'), ('device_token', 'platform')]
+        ordering = ['-last_seen']
+
+    class RestMeta:
+        VIEW_PERMS = ["view_devices", "manage_devices", "owner", "manage_users"]
+        SAVE_PERMS = ["manage_devices", "owner"]
+        SEARCH_FIELDS = ["device_name", "device_id"]
+        LIST_DEFAULT_FILTERS = {"is_active": True}
+        GRAPHS = {
+            "basic": {
+                "fields": ["id", "device_id", "platform", "device_name", "push_enabled", "last_seen"]
+            },
+            "default": {
+                "fields": ["id", "device_id", "platform", "device_name", "app_version",
+                          "os_version", "push_enabled", "push_preferences", "last_seen"],
+                "graphs": {
+                    "user": "basic"
+                }
+            },
+            "full": {
+                "graphs": {
+                    "user": "default"
+                }
+            }
+        }
+
+    def __str__(self):
+        return f"{self.device_name or self.device_id} ({self.platform}) - {self.user.username}"