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

mojo/apps/account/models/group.py

@@ -1,7 +1,11 @@
 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
 
+GROUP_LAST_ACTIVITY_FREQ = settings.get("GROUP_LAST_ACTIVITY_FREQ", 300)
+METRICS_TIMEZONE = settings.get("METRICS_TIMEZONE", "America/Los_Angeles")
 
 
 class Group(MojoSecrets, MojoModel):
@@ -10,6 +14,7 @@ class Group(MojoSecrets, MojoModel):
     """
     created = models.DateTimeField(auto_now_add=True, editable=False)
     modified = models.DateTimeField(auto_now=True, db_index=True)
+    last_activity = models.DateTimeField(default=None, null=True, db_index=True)
 
     name = models.CharField(max_length=200)
     uuid = models.CharField(max_length=200, null=True, default=None, db_index=True)
@@ -22,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"]
@@ -36,9 +45,13 @@ class Group(MojoSecrets, MojoModel):
                     'name',
                     'created',
                     'modified',
+                    'last_activity',
                     'is_active',
                     'kind',
-                ]
+                ],
+                "graphs": {
+                    "avatar": "basic"
+                }
             },
             "default": {
                 "fields": [
@@ -46,15 +59,33 @@ class Group(MojoSecrets, MojoModel):
                     'name',
                     'created',
                     'modified',
+                    'last_activity',
                     'is_active',
                     'kind',
                     'parent',
                     'metadata'
-                ]
+                ],
+                "graphs": {
+                    "avatar": "basic",
+                    "parent": "basic"
+                }
             },
-            "graphs": {
-                "parent": "basic"
-            }
+
+        }
+        FORMATS = {
+            "csv": [
+                "id",
+                "uuid",
+                "name",
+                "created",
+                "modified",
+                "last_activity",
+                "is_active",
+                "kind",
+                "parent.id",
+                "parent.name",
+                ("metadata.timezone", "timezone")
+            ]
         }
 
     @property
@@ -68,31 +99,304 @@ class Group(MojoSecrets, MojoModel):
         return dates.get_local_time(self.timezone, dt_utc)
 
     def __str__(self):
-        return self.name
+        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
 
+    def touch(self):
+        # can't subtract offset-naive and offset-aware datetimes
+        if self.last_activity and not dates.is_today(self.last_activity, METRICS_TIMEZONE):
+            metrics.record("group_activity_day", category="group", min_granularity="days")
+        if self.last_activity is None or dates.has_time_elsapsed(self.last_activity, seconds=GROUP_LAST_ACTIVITY_FREQ):
+            self.last_activity = dates.utcnow()
+            self.atomic_save()
+
     def get_metadata(self):
         # converts our local metadata into an objict
         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"):
             return cls.on_rest_list(request)
-        group_ids = request.user.members.values_list('group__id', flat=True)
-        return cls.on_rest_list(request, cls.objects.filter(id__in=group_ids))
+        if getattr(request.user, 'members') is not None:
+            group_ids = request.user.members.values_list('group__id', flat=True)
+            return cls.on_rest_list(request, cls.objects.filter(id__in=group_ids))
+        return cls.on_rest_list(request, cls.objects.none())

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
         }
@@ -34,7 +35,6 @@ class GroupMember(models.Model, MojoModel):
             "default": {
                 "fields": [
                     'id',
-                    'name',
                     'created',
                     'modified',
                     'is_active',
@@ -42,7 +42,7 @@ class GroupMember(models.Model, MojoModel):
                     'metadata'
                 ],
                 "graphs": {
-                    "user": "basic",
+                    "user": "default",
                     "group": "basic"
                 }
             }
@@ -51,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
@@ -61,11 +73,11 @@ class GroupMember(models.Model, MojoModel):
             return req_member.has_permission(["manage_group", "manage_members"])
         return False
 
-    def set_permissions(self, value, request):
+    def set_permissions(self, value):
             if not isinstance(value, dict):
                 return
             for perm, perm_value in value.items():
-                if not self.can_change_permission(perm, perm_value, request):
+                if not self.can_change_permission(perm, perm_value, self.active_request):
                     raise merrors.PermissionDeniedException()
                 if bool(perm_value):
                     self.add_permission(perm)
@@ -73,12 +85,24 @@ class GroupMember(models.Model, MojoModel):
                     self.remove_permission(perm)
 
     def has_permission(self, perm_key):
-        """Check if user has a specific permission in JSON field."""
+        """
+        Check if user has a specific permission—supports system-level permissions via 'sys.' prefix.
+        If perm_key starts with 'sys.', only the user-level permission is checked.
+        Otherwise, checks group-member-level permission as before.
+        """
+        # Support lists for "OR" logic
         if isinstance(perm_key, list):
             for pk in perm_key:
                 if self.has_permission(pk):
                     return True
             return False
+
+        # System-level: only check user permission
+        SYS_PREFIX = "sys."
+        if isinstance(perm_key, str) and perm_key.startswith(SYS_PREFIX):
+            bare_perm = perm_key[len(SYS_PREFIX):]
+            return self.user.has_permission(bare_perm)
+
         if perm_key == "all":
             return True
         return self.permissions.get(perm_key, False)

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'])