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

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

@@ -0,0 +1,99 @@
+from django.db import models
+from mojo.models import MojoModel
+
+
+class NotificationTemplate(models.Model, MojoModel):
+    """
+    Reusable notification templates with variable substitution support.
+    """
+    created = models.DateTimeField(auto_now_add=True, editable=False, db_index=True)
+    modified = models.DateTimeField(auto_now=True, db_index=True)
+
+    group = models.ForeignKey("account.Group", on_delete=models.CASCADE,
+                             related_name="notification_templates", null=True, blank=True,
+                             help_text="Organization for this template. Null = system template")
+
+    name = models.CharField(max_length=100, db_index=True)
+    title_template = models.CharField(max_length=200, blank=True, null=True)
+    body_template = models.TextField(blank=True, null=True)
+    action_url = models.URLField(blank=True, null=True, help_text="Template URL with variable support")
+    data_template = models.JSONField(default=dict, blank=True,
+                                   help_text="Template data payload with variable support")
+
+    # Delivery preferences
+    category = models.CharField(max_length=50, default="general", db_index=True)
+    priority = models.CharField(max_length=20, choices=[
+        ('low', 'Low'),
+        ('normal', 'Normal'),
+        ('high', 'High')
+    ], default='normal', db_index=True)
+
+    # Template variables documentation
+    variables = models.JSONField(default=dict, blank=True,
+                               help_text="Expected template variables and descriptions for title, body, action_url, and data_template")
+
+    is_active = models.BooleanField(default=True, db_index=True)
+
+    class Meta:
+        ordering = ['group__name', 'name']
+        unique_together = [('group', 'name')]
+
+    class RestMeta:
+        VIEW_PERMS = ["manage_notifications", "manage_groups", "owner", "manage_users"]
+        SAVE_PERMS = ["manage_notifications", "manage_groups"]
+        SEARCH_FIELDS = ["name", "category"]
+        LIST_DEFAULT_FILTERS = {"is_active": True}
+        GRAPHS = {
+            "basic": {
+                "fields": ["id", "name", "category", "priority", "is_active"]
+            },
+            "default": {
+                "fields": ["id", "name", "title_template", "body_template", "action_url",
+                          "data_template", "category", "priority", "variables", "is_active"],
+                "graphs": {
+                    "group": "basic"
+                }
+            },
+            "full": {
+                "graphs": {
+                    "group": "default"
+                }
+            }
+        }
+
+    def __str__(self):
+        org = self.group.name if self.group else "System"
+        return f"{self.name} ({org})"
+
+    def clean(self):
+        """Validate that at least one template field is provided."""
+        from django.core.exceptions import ValidationError
+
+        has_title = self.title_template and self.title_template.strip()
+        has_body = self.body_template and self.body_template.strip()
+        has_data = self.data_template and bool(self.data_template)
+
+        if not (has_title or has_body or has_data):
+            raise ValidationError(
+                "Template must have at least one of: title_template, body_template, or data_template"
+            )
+
+    def render(self, context):
+        """
+        Render template with provided context variables.
+        Returns tuple of (title, body, action_url, data)
+        """
+        title = self.title_template.format(**context) if self.title_template else None
+        body = self.body_template.format(**context) if self.body_template else None
+        action_url = self.action_url.format(**context) if self.action_url else None
+
+        # Render data template with context
+        data = {}
+        if self.data_template:
+            for key, value in self.data_template.items():
+                if isinstance(value, str):
+                    data[key] = value.format(**context)
+                else:
+                    data[key] = value
+
+        return title, body, action_url, data

mojo/apps/account/models/user.py

@@ -6,6 +6,7 @@ from mojo import errors as merrors
 from mojo.helpers import dates
 from mojo.apps.account.utils.jwtoken import JWToken
 from mojo.apps import metrics
+from .device import UserDevice
 import uuid
 
 SYS_USER_PERMS_PROTECTION = {
@@ -28,6 +29,7 @@ USER_PERMS_PROTECTION.update(SYS_USER_PERMS_PROTECTION)
 
 USER_LAST_ACTIVITY_FREQ = settings.get("USER_LAST_ACTIVITY_FREQ", 300)
 METRICS_TIMEZONE = settings.get("METRICS_TIMEZONE", "America/Los_Angeles")
+METRICS_TRACK_USER_ACTIVITY = settings.get("METRICS_TRACK_USER_ACTIVITY", False)
 
 class CustomUserManager(BaseUserManager):
     def create_user(self, email, password=None, **extra_fields):
@@ -62,6 +64,11 @@ class User(MojoSecrets, AbstractBaseUser, MojoModel):
     phone_number = models.CharField(max_length=32, blank=True, null=True, default=None)
     is_active = models.BooleanField(default=True, db_index=True)
     display_name = models.CharField(max_length=80, blank=True, null=True, default=None)
+
+    # Organization relationship for push config resolution
+    org = models.ForeignKey("account.Group", on_delete=models.SET_NULL,
+                           null=True, blank=True, related_name="org_users",
+                           help_text="Default organization for this user")
     # key used for sessions and general authentication algs
     auth_key = models.TextField(null=True, default=None)
     onetime_code = models.TextField(null=True, default=None)
@@ -88,6 +95,8 @@ class User(MojoSecrets, AbstractBaseUser, MojoModel):
     objects = CustomUserManager()
 
     class RestMeta:
+        LOG_CHANGES = True
+        POST_SAVE_ACTIONS = ['send_invite']
         NO_SHOW_FIELDS = ["password", "auth_key", "onetime_code"]
         SEARCH_FIELDS = ["username", "email", "display_name"]
         VIEW_PERMS = ["view_users", "manage_users", "owner"]
@@ -124,7 +133,8 @@ class User(MojoSecrets, AbstractBaseUser, MojoModel):
                     'is_active'
                 ],
                 "graphs": {
-                    "avatar": "basic"
+                    "avatar": "basic",
+                    "org": "basic"
                 }
             },
             "full": {
@@ -151,6 +161,12 @@ class User(MojoSecrets, AbstractBaseUser, MojoModel):
         if self.last_activity is None or dates.has_time_elsapsed(self.last_activity, seconds=USER_LAST_ACTIVITY_FREQ):
             self.last_activity = dates.utcnow()
             self.atomic_save()
+        if METRICS_TRACK_USER_ACTIVITY:
+            metrics.record(f"user_activity:{self.pk}", category="user", min_granularity="minutes")
+
+    def track(self, request):
+        self.touch()
+        UserDevice.track(request)
 
     def get_auth_key(self):
         if self.auth_key is None:
@@ -323,8 +339,16 @@ class User(MojoSecrets, AbstractBaseUser, MojoModel):
         # Fall back to using the full email as username
         return self.email.lower()
 
+    def generate_display_name(self):
+        """Generate a display name from email, falling back to email if username exists."""
+        # Try using the part before @ as display name
+        # generate display name from usernames like "bob.smith", "bob_smith", "bob.smith@example.com"
+        # Extract the base part (before @ if email format)
+        base_username = self.username.split("@")[0] if "@" in self.username else self.username
+        # Replace underscores and dots with spaces, then title case
+        return base_username.replace("_", " ").replace(".", " ").title()
+
     def on_rest_pre_save(self, changed_fields, created):
-        self.debug("PRE SAVE")
         creds_changed = False
         if "email" in changed_fields:
             creds_changed = True
@@ -348,29 +372,178 @@ class User(MojoSecrets, AbstractBaseUser, MojoModel):
                 qset = qset.exclude(pk=self.pk)
             if qset.exists():
                 raise merrors.ValueException("Username already exists")
+        if not self.display_name:
+            self.display_name = self.generate_display_name()
         if self.pk is not None:
-            # only super user can change email or username
-            if creds_changed and not self.active_user.is_superuser:
-                raise merrors.PermissionDeniedException("You are not allowed to change email or username")
-            if "password" in changed_fields:
+            self._handle_new_user_pre_save(creds_changed, changed_fields)
+
+    def _handle_new_user_pre_save(self, creds_changed, changed_fields):
+        # only super user can change email or username
+        if creds_changed and not self.active_user.is_superuser:
+            raise merrors.PermissionDeniedException("You are not allowed to change email or username")
+        if "password" in changed_fields:
+            raise merrors.PermissionDeniedException("You are not allowed to change password")
+        if "new_password" in changed_fields:
+            if not self.can_change_password():
                 raise merrors.PermissionDeniedException("You are not allowed to change password")
-            if "new_password" in changed_fields:
-                if not self.can_change_password():
-                    raise merrors.PermissionDeniedException("You are not allowed to change password")
-                self.debug("CHANGING PASSWORD")
-                self.log("****", kind="password:changed")
-            if "email" in changed_fields:
-                self.log(kind="email:changed", log=f"{changed_fields['email']} to {self.email}")
-            if "username" in changed_fields:
-                self.log(kind="username:changed", log=f"{changed_fields['username']} to {self.username}")
-        self.debug("on_rest_pre_save", changed_fields, creds_changed, self.active_user.is_superuser)
-
+            self.debug("CHANGING PASSWORD")
+            self.log("****", kind="password:changed")
+        if "email" in changed_fields:
+            self.log(kind="email:changed", log=f"{changed_fields['email']} to {self.email}")
+        if "username" in changed_fields:
+            self.log(kind="username:changed", log=f"{changed_fields['username']} to {self.username}")
+        if "is_active" in changed_fields:
+            if not self.is_active:
+                metrics.record("user_deactivated", category="user", min_granularity="hours")
+            metrics.set_value("total_users", User.objects.filter(is_active=True).count(), account="global")
 
     def check_edit_permission(self, perms, request):
         if "owner" in perms and self.is_request_user():
             return True
         return request.user.has_permission(perms)
 
+    def on_action_send_invite(self, value):
+        self.send_invite()
+
+    def push_notification(self, title=None, body=None, data=None,
+                          category="general", action_url=None,
+                          devices=None, user_ids=None, delay=None):
+        from mojo.apps.account.services.push import send_direct_notification
+        send_direct_notification(
+            self, title=title, body=body, data=data, category=category,
+            action_url=action_url,
+            devices=devices, user_ids=user_ids, delay=delay)
+
+    def send_invite(self):
+        self.send_template_email(
+            template_name="invite",
+            context={"user": self.to_dict("basic")}
+        )
+
+    def send_email(
+        self,
+        subject=None,
+        body_text=None,
+        body_html=None,
+        cc=None,
+        bcc=None,
+        reply_to=None,
+        **kwargs
+    ):
+        """Send email to this user using mailbox determined by user's org domain or system default
+
+        Args:
+            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
+
+        # Try to get mailbox from org domain
+        if self.org and hasattr(self.org, 'metadata'):
+            domain = self.org.metadata.get("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=self.email,
+            subject=subject,
+            body_text=body_text,
+            body_html=body_html,
+            cc=cc,
+            bcc=bcc,
+            reply_to=reply_to,
+            **kwargs
+        )
+
+    def send_template_email(
+        self,
+        template_name,
+        context=None,
+        cc=None,
+        bcc=None,
+        reply_to=None,
+        **kwargs
+    ):
+        """Send template email to this user using mailbox determined by user's org domain or system default
+
+        Args:
+            template_name: Name of the EmailTemplate in database
+            context: Template context variables (user 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
+
+        # Try to get mailbox from org domain
+        if self.org and hasattr(self.org, 'metadata'):
+            domain = self.org.metadata.get("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 user to context if not already present
+        if context is None:
+            context = {}
+        if 'user' not in context:
+            context['user'] = self.to_dict("basic")
+
+        return mailbox.send_template_email(
+            to=self.email,
+            template_name=template_name,
+            context=context,
+            cc=cc,
+            bcc=bcc,
+            reply_to=reply_to,
+            allow_unverified=True,
+            **kwargs
+        )
+
     @classmethod
     def validate_jwt(cls, token):
         token_manager = JWToken()

mojo/apps/account/rest/__init__.py

@@ -1,3 +1,5 @@
 APP_NAME = ""
 from .user import *
 from .group import *
+from .device import *
+from .push import *

mojo/apps/account/rest/device.py

@@ -0,0 +1,39 @@
+from mojo import decorators as md
+from mojo.apps.account.models.device import UserDevice, UserDeviceLocation, GeoLocatedIP
+
+
+@md.URL('user/device')
+@md.URL('user/device/<int:pk>')
+def on_user_device(request, pk=None):
+    return UserDevice.on_rest_request(request, pk)
+
+
+@md.GET('user/device/lookup')
+@md.requires_params('duid')
+def on_user_device_by_duid(request):
+    duid = request.DATA.get('duid')
+    device = UserDevice.objects.filter(duid=duid).first()
+    if not device:
+        return UserDevice.rest_error_response(request, 404, error="Device not found")
+    return device.on_rest_get(request)
+
+
+@md.URL('user/device/location')
+@md.URL('user/device/location/<int:pk>')
+def on_user_device_location(request, pk=None):
+    return UserDeviceLocation.on_rest_request(request, pk)
+
+
+@md.URL('system/geoip')
+@md.URL('system/geoip/<int:pk>')
+def on_geo_located_ip(request, pk=None):
+    return GeoLocatedIP.on_rest_request(request, pk)
+
+
+@md.GET('system/geoip/lookup')
+@md.requires_params('ip')
+def on_geo_located_ip_lookup(request):
+    ip_address = request.DATA.get('ip')
+    auto_refresh = request.DATA.get('auto_refresh', True)
+    geo_ip = GeoLocatedIP.geolocate(ip_address, auto_refresh=auto_refresh)
+    return geo_ip.on_rest_get(request)

mojo/apps/account/rest/group.py

@@ -1,5 +1,6 @@
 from mojo import decorators as md
 from mojo.apps.account.models import Group, GroupMember
+from mojo.helpers.response import JsonResponse
 
 
 @md.URL('group')
@@ -14,6 +15,13 @@ def on_group_member(request, pk=None):
     return GroupMember.on_rest_request(request, pk)
 
 
+@md.POST('group/member/invite')
+@md.requires_params('email', 'group')
+def on_group_invite_member(request):
+    ms = request.group.invite(request.DATA['email'])
+    return ms.on_rest_get(request)
+
+
 @md.GET('group/<int:pk>/member')
 def on_group_me_member(request, pk=None):
     request.group = Group.objects.filter(pk=pk).last()

mojo/apps/account/rest/push.py

@@ -0,0 +1,187 @@
+import mojo.decorators as md
+from mojo.apps.account.models import (
+    RegisteredDevice, NotificationTemplate, PushConfig,
+    NotificationDelivery
+)
+from mojo.apps.account.services.push import (
+    send_push_notification, send_direct_notification
+)
+from mojo.helpers import response
+
+
+@md.POST('account/devices/push/register')
+@md.requires_auth()
+@md.requires_params(['device_token', 'device_id', 'platform'])
+def register_device(request):
+    """
+    Register device for push notifications.
+
+    POST /api/account/devices/push/register
+    {
+        "device_token": "...",
+        "device_id": "...",
+        "platform": "ios|android|web",
+        "device_name": "...",
+        "app_version": "...",
+        "os_version": "...",
+        "push_preferences": {"orders": true, "marketing": false}
+    }
+    """
+    device, created = RegisteredDevice.objects.update_or_create(
+        user=request.user,
+        device_id=request.DATA.get('device_id'),
+        defaults={
+            'device_token': request.DATA.get('device_token'),
+            'platform': request.DATA.get('platform'),
+            'device_name': request.DATA.get('device_name', ''),
+            'app_version': request.DATA.get('app_version', ''),
+            'os_version': request.DATA.get('os_version', ''),
+            'push_preferences': request.DATA.get('push_preferences', {}),
+            'is_active': True,
+            'push_enabled': True
+        }
+    )
+
+    return device.on_rest_get(request, 'default')
+
+
+@md.URL('account/devices/push')
+@md.URL('account/devices/push/<int:pk>')
+def on_registered_devices(request, pk=None):
+    """Standard CRUD for registered devices."""
+    return RegisteredDevice.on_rest_request(request, pk)
+
+
+@md.URL('account/devices/push/templates')
+@md.URL('account/devices/push/templates/<int:pk>')
+def on_notification_templates(request, pk=None):
+    """Standard CRUD for notification templates."""
+    return NotificationTemplate.on_rest_request(request, pk)
+
+
+@md.URL('account/devices/push/config')
+@md.URL('account/devices/push/config/<int:pk>')
+def on_push_config(request, pk=None):
+    """Standard CRUD for push configuration."""
+    return PushConfig.on_rest_request(request, pk)
+
+
+@md.URL('account/devices/push/deliveries')
+@md.URL('account/devices/push/deliveries/<int:pk>')
+def on_notification_deliveries(request, pk=None):
+    """Standard CRUD for notification delivery history."""
+    return NotificationDelivery.on_rest_request(request, pk)
+
+
+@md.POST('account/devices/push/send')
+@md.requires_auth()
+@md.requires_perms("send_notifications")
+def send_notification(request):
+    """
+    Send push notification using template or direct content.
+
+    POST /api/account/devices/push/send
+
+    Templated:
+    {
+        "template": "template_name",
+        "context": {"key": "value"},
+        "user_ids": [1, 2, 3]  # optional
+    }
+
+    Direct:
+    {
+        "title": "Hello!",
+        "body": "Your order is ready",
+        "category": "orders",
+        "action_url": "myapp://orders/123",
+        "user_ids": [1, 2, 3]  # optional
+    }
+    """
+    template = request.DATA.get('template')
+    title = request.DATA.get('title')
+    body = request.DATA.get('body')
+
+    if template:
+        # Templated sending
+        context = request.DATA.get('context', {})
+        user_ids = request.DATA.get('user_ids')
+        results = send_push_notification(
+            user=request.user,
+            template_name=template,
+            context=context,
+            user_ids=user_ids
+        )
+    elif title and body:
+        # Direct sending
+        category = request.DATA.get('category', 'general')
+        action_url = request.DATA.get('action_url')
+        user_ids = request.DATA.get('user_ids')
+        results = send_direct_notification(
+            user=request.user,
+            title=title,
+            body=body,
+            category=category,
+            action_url=action_url,
+            user_ids=user_ids
+        )
+    else:
+        return response.error('Must provide either template or both title and body')
+
+    return response.success({
+        'success': True,
+        'sent_count': len([r for r in results if r.status == 'sent']),
+        'failed_count': len([r for r in results if r.status == 'failed']),
+        'deliveries': [r.to_dict("basic") for r in results]
+    })
+
+
+@md.POST('account/devices/push/test')
+@md.requires_auth()
+def test_push_config(request):
+    """
+    Test push configuration by sending a test notification to requesting user's devices.
+
+    POST /api/account/devices/push/test
+    {
+        "message": "Custom test message" # optional
+    }
+    """
+    test_message = request.DATA.get('message', 'This is a test notification')
+
+    results = send_direct_notification(
+        user=request.user,
+        title="Push Test",
+        body=test_message,
+        category="test"
+    )
+
+    if not results:
+        return response.error('No registered devices found for testing')
+
+    return response.success({
+        'success': True,
+        'message': 'Test notifications sent',
+        'results': [r.to_dict('basic') for r in results]
+    })
+
+
+@md.GET('account/devices/push/stats')
+@md.requires_auth()
+def push_stats(request):
+    """
+    Get push notification statistics for the requesting user.
+    """
+    user_deliveries = NotificationDelivery.objects.filter(user=request.user)
+
+    stats = {
+        'total_sent': user_deliveries.filter(status='sent').count(),
+        'total_failed': user_deliveries.filter(status='failed').count(),
+        'total_pending': user_deliveries.filter(status='pending').count(),
+        'registered_devices': request.user.registered_devices.filter(is_active=True).count(),
+        'enabled_devices': request.user.registered_devices.filter(
+            is_active=True, push_enabled=True
+        ).count()
+    }
+
+    return response.success(stats)