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

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,11 +15,19 @@ 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()
     if request.group is None:
         return Group.rest_error_response(request, 403, error="GET permission denied: Group")
+    request.group.touch()
     member = request.group.get_member_for_user(request.user)
     if member is None:
         return Group.rest_error_response(request, 403, error="GET permission denied: Member")

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)

mojo/apps/account/rest/user.py

@@ -3,7 +3,8 @@ from mojo.apps.account.utils.jwtoken import JWToken
 # from django.http import JsonResponse
 from mojo.helpers.response import JsonResponse
 from mojo.apps.account.models.user import User
-import datetime
+from mojo.helpers import dates, crypto
+from mojo import errors as merrors
 
 @md.URL('user')
 @md.URL('user/<int:pk>')
@@ -17,11 +18,13 @@ def on_user_me(request):
 
 
 @md.POST('refresh_token')
+@md.POST('token/refresh')
+@md.POST("auth/token/refresh")
 @md.requires_params("refresh_token")
 def on_refresh_token(request):
     user, error = User.validate_jwt(request.DATA.refresh_token)
     if error is not None:
-        return JsonResponse({'error': error}, status=401)
+        raise merrors.PermissionDeniedException(error, 401, 401)
     # future look at keeping the refresh token the same but updating the access_token
     # TODO add device id to the token as well
     user.touch()
@@ -30,18 +33,109 @@ def on_refresh_token(request):
 
 
 @md.POST("login")
+@md.POST("auth/login")
 @md.requires_params("username", "password")
 def on_user_login(request):
     username = request.DATA.username
     password = request.DATA.password
-    user = User.objects.filter(username=username.lower().strip()).last()
+    from django.db.models import Q
+    user = User.objects.filter(Q(username=username.lower().strip()) | Q(email=username.lower().strip())).last()
     if user is None:
-        return JsonResponse(dict(status=False, error="Invalid username or password", code=403))
+        User.class_report_incident(
+            f"login attempt with unknown username {username}",
+            event_type="login:unknown",
+            level=8,
+            request=request)
+        raise merrors.PermissionDeniedException()
     if not user.check_password(password):
         # Authentication successful
         user.report_incident(f"{user.username} enter an invalid password", "invalid_password")
-        return JsonResponse(dict(status=False, error="Invalid username or password", code=401))
-    user.last_login = datetime.datetime.utcnow()
+        raise merrors.PermissionDeniedException("Invalid username or password", 401, 401)
+    user.last_login = dates.utcnow()
     user.touch()
     token_package = JWToken(user.get_auth_key()).create(uid=user.id)
+    token_package['user'] = user.to_dict("basic")
     return JsonResponse(dict(status=True, data=token_package))
+
+
+@md.POST("auth/forgot")
+@md.requires_params("email")
+def on_user_forgot(request):
+    email = request.DATA.email
+    user = User.objects.filter(email=email.lower().strip()).last()
+    if user is None:
+        User.class_report_incident(
+            f"reset password with unknown email {email}",
+            event_type="reset:unknown",
+            level=8,
+            request=request)
+    else:
+        user.report_incident(f"{user.username} requested a password reset", "password_reset")
+        if request.DATA.get("method") == "code":
+            code = crypto.random_string(6, True, False, False)
+            user.set_secret("password_reset_code", code)
+            user.save()
+            user.send_template_email("password_reset_code", dict(code=code))
+        elif request.DATA.get("method") in ["link", "email"]:
+            user.send_template_email("password_reset_link", dict(token=generate_password_reset_token(user)))
+        else:
+            raise merrors.ValueException("Invalid method")
+    return JsonResponse(dict(status=True, message="If email in our system a reset email was sent."))
+
+
+def generate_password_reset_token(user):
+    token = crypto.b64_encode({"uid":user.pk, "r": crypto.random_string(6, True, True, False)})
+    sig = crypto.sign(token, user.get_auth_key())
+    hex_token = token.encode("utf-8").hex() + sig[-6:]
+    return hex_token
+
+
+def verify_password_reset_token(hex_token):
+    orig_token = hex_token
+    try:
+        tsig = hex_token[-6:]
+        hex_token = hex_token[:-6]
+        token = bytes.fromhex(hex_token).decode("utf-8")
+        obj = crypto.b64_decode(token)
+        if not isinstance(obj, dict) or "uid" not in obj:
+            raise merrors.ValueException("Invalid token")
+        user = User.objects.get(pk=obj["uid"])
+        sig = crypto.sign(token, user.get_auth_key())
+        if sig[-6:] != tsig:
+            user.report_incident(f"{user.username} invalid reset token", "invalid_reset_token")
+            raise merrors.ValueException("Invalid token")
+        return user
+    except Exception:
+        pass
+    User.class_report_incident(
+        "invalid reset token",
+        event_type="reset:unknown",
+        level=8, token=orig_token)
+    raise merrors.ValueException("Invalid token")
+
+
+@md.POST("auth/password/reset/code")
+@md.requires_params("code", "email", "new_password")
+def on_user_password_reset_code(request):
+    code = request.DATA.get("code")
+    email = request.DATA.get("email")
+    new_password = request.DATA.get("new_password")
+    user = User.objects.get(email=email)
+    sec_code = user.get_secret("password_reset_code")
+    if len(sec_code) != 6 or len(code) != 6 or code != sec_code:
+        user.report_incident(f"{user.username} invalid password reset code", "password_reset")
+        raise merrors.ValueException("Invalid code")
+    user.set_password(new_password)
+    user.save()
+    return JsonResponse(dict(status=True, message="Password reset successful."))
+
+
+@md.POST("auth/password/reset/token")
+@md.requires_params("token", "new_password")
+def on_user_password_reset_token(request):
+    token = request.DATA.get("token")
+    user = verify_password_reset_token(token)
+    new_password = request.DATA.get("new_password")
+    user.set_password(new_password)
+    user.save()
+    return JsonResponse(dict(status=True, message="Password reset successful."))

mojo/apps/account/services/__init__.py

@@ -0,0 +1 @@
+# Push notification services