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

mojo/apps/metrics/rest/permissions.py

@@ -0,0 +1,99 @@
+from mojo import decorators as md
+from mojo.apps import metrics
+from mojo.helpers.response import JsonResponse
+import mojo.errors
+
+
+@md.URL('permissions')
+@md.URL('permissions/<str:account>')
+@md.requires_perms("manage_incidents")
+def on_permissions(request, account=None):
+    if request.method == 'GET':
+        if account is None:
+            return on_list_permissions(request)
+        return on_get_permissions(request, account)
+    if request.method == 'POST':
+        if not account:
+            account = request.DATA.get("account", None)
+        if account:
+            return on_set_permissions(request, account)
+    if request.method == 'DELETE' and account:
+        return on_delete_permissions(request, account)
+    return JsonResponse({
+        "method": request.method,
+        "error": "Invalid method",
+        "status": False
+    })
+
+def on_get_permissions(request, account):
+    """
+    Get current view and write permissions for an account.
+    """
+    view_perms = metrics.get_view_perms(account)
+    write_perms = metrics.get_write_perms(account)
+
+    return JsonResponse({
+        "id": account,
+        "account": account,
+        "view_permissions": view_perms,
+        "write_permissions": write_perms,
+        "status": True
+    })
+
+
+def on_set_permissions(request, account):
+    """
+    Set view permissions for an account.
+    """
+    view_perms = request.DATA.get("view_permissions", "").split(",")
+    write_perms = request.DATA.get("write_permissions", "").split(",")
+
+    if view_perms:
+        metrics.set_view_perms(account, view_perms)
+    if write_perms:
+        metrics.set_write_perms(account, write_perms)
+
+    return JsonResponse({
+        "id": account,
+        "account": account,
+        "view_permissions": view_perms,
+        "write_permissions": write_perms,
+        "action": "set",
+        "status": True
+    })
+
+
+def on_delete_permissions(request, account):
+    """
+    Remove all permissions for an account.
+    """
+    # Remove both view and write permissions
+    metrics.set_view_perms(account, None)
+    metrics.set_write_perms(account, None)
+
+    return JsonResponse({
+        "account": account,
+        "action": "deleted",
+        "status": True
+    })
+
+
+def on_list_permissions(request):
+    """
+    List all accounts that have permissions configured.
+    """
+    accounts = metrics.list_accounts()
+    data = []
+    for account in accounts:
+        info = {"account": account, "id": account}
+        info["view_permissions"] = metrics.get_view_perms(account)
+        info["write_permissions"] = metrics.get_write_perms(account)
+        data.append(info)
+
+    return JsonResponse({
+        "data": data,
+        "size": 10,
+        "start": 0,
+        "count": len(accounts),
+        "status": True
+    })

mojo/apps/metrics/rest/values.py

@@ -0,0 +1,277 @@
+from mojo import decorators as md
+from mojo.apps import metrics
+from mojo.helpers.response import JsonResponse
+import mojo.errors
+import datetime
+from .helpers import check_view_permissions, check_write_permissions
+
+# Documentation for time-series metrics endpoints
+SERIES_GET_DOCS = {
+    "summary": "Get time-series values at a point in time",
+    "description": "Retrieves time-series metric values for multiple slugs at a specific datetime and granularity.",
+    "parameters": [
+        {
+            "name": "slugs",
+            "in": "query",
+            "required": True,
+            "schema": {"type": "string"},
+            "description": "Comma-separated list of slugs to fetch values for (e.g., 'user_activity_day,page_views')."
+        },
+        {
+            "name": "when",
+            "in": "query",
+            "required": True,
+            "schema": {"type": "string", "format": "date-time"},
+            "description": "The specific date/datetime to fetch values for."
+        },
+        {
+            "name": "granularity",
+            "in": "query",
+            "schema": {"type": "string", "default": "hours"},
+            "description": "Granularity of the data (e.g., 'hours', 'days', 'months', 'years')."
+        },
+        {
+            "name": "account",
+            "in": "query",
+            "schema": {"type": "string", "default": "public"},
+            "description": "Account identifier (e.g., 'public', 'global', or 'group_<id>')."
+        }
+    ],
+    "responses": {
+        "200": {
+            "description": "Successful response with metric values.",
+            "content": {
+                "application/json": {
+                    "example": {
+                        "response": {
+                            "data": {
+                                "user_activity_day": 22,
+                                "page_views": 156
+                            },
+                            "slugs": ["user_activity_day", "page_views"],
+                            "when": "2025-08-01T00:00:00",
+                            "granularity": "days",
+                            "account": "public",
+                            "status": True
+                        },
+                        "status_code": 200
+                    }
+                }
+            }
+        }
+    }
+}
+
+SERIES_POST_DOCS = {
+    "summary": "Get time-series values at a point in time (POST)",
+    "description": "Retrieves time-series metric values for multiple slugs at a specific datetime and granularity using POST method.",
+    "parameters": [
+        {
+            "name": "slugs",
+            "in": "body",
+            "required": True,
+            "schema": {"type": "string"},
+            "description": "Comma-separated list of slugs to fetch values for (e.g., 'user_activity_day,page_views')."
+        },
+        {
+            "name": "when",
+            "in": "body",
+            "required": True,
+            "schema": {"type": "string", "format": "date-time"},
+            "description": "The specific date/datetime to fetch values for."
+        },
+        {
+            "name": "granularity",
+            "in": "body",
+            "schema": {"type": "string", "default": "hours"},
+            "description": "Granularity of the data (e.g., 'hours', 'days', 'months', 'years')."
+        },
+        {
+            "name": "account",
+            "in": "body",
+            "schema": {"type": "string", "default": "public"},
+            "description": "Account identifier (e.g., 'public', 'global', or 'group_<id>')."
+        }
+    ]
+}
+
+# Documentation for simple value storage endpoints
+SET_VALUE_DOCS = {
+    "summary": "Set simple global values",
+    "description": "Sets simple key-value pairs for global storage (not time-series).",
+    "parameters": [
+        {
+            "name": "slug",
+            "in": "body",
+            "required": True,
+            "schema": {"type": "string"},
+            "description": "The key identifier for the value to set."
+        },
+        {
+            "name": "value",
+            "in": "body",
+            "required": True,
+            "schema": {"type": "string"},
+            "description": "The value to store."
+        },
+        {
+            "name": "account",
+            "in": "body",
+            "schema": {"type": "string", "default": "public"},
+            "description": "Account identifier (e.g., 'public', 'global', or 'group_<id>')."
+        }
+    ],
+    "responses": {
+        "200": {
+            "description": "Successful value storage.",
+            "content": {
+                "application/json": {
+                    "example": {
+                        "response": {
+                            "slug": "max_users",
+                            "value": "1000",
+                            "account": "public",
+                            "status": True
+                        },
+                        "status_code": 200
+                    }
+                }
+            }
+        }
+    }
+}
+
+VALUE_GET_DOCS = {
+    "summary": "Get simple global values",
+    "description": "Retrieves simple key-value pairs from global storage (not time-series). Supports multiple slugs.",
+    "parameters": [
+        {
+            "name": "slugs",
+            "in": "query",
+            "required": True,
+            "schema": {"type": "string"},
+            "description": "Comma-separated list of slugs to fetch values for (e.g., 'max_users,maintenance_mode')."
+        },
+        {
+            "name": "account",
+            "in": "query",
+            "schema": {"type": "string", "default": "public"},
+            "description": "Account identifier (e.g., 'public', 'global', or 'group_<id>')."
+        },
+        {
+            "name": "default",
+            "in": "query",
+            "schema": {"type": "string"},
+            "description": "Default value to return for missing keys."
+        }
+    ],
+    "responses": {
+        "200": {
+            "description": "Successful response with values.",
+            "content": {
+                "application/json": {
+                    "example": {
+                        "response": {
+                            "data": {
+                                "max_users": "1000",
+                                "maintenance_mode": "false"
+                            },
+                            "slugs": ["max_users", "maintenance_mode"],
+                            "account": "public",
+                            "status": True
+                        },
+                        "status_code": 200
+                    }
+                }
+            }
+        }
+    }
+}
+
+
+# Time-series metrics endpoints
+@md.GET('series', docs=SERIES_GET_DOCS)
+@md.requires_params("slugs")
+def on_metrics_series(request):
+    """
+    Get time-series values for multiple slugs at a single point in time.
+    """
+    when = request.DATA.get_typed("when")
+    account = request.DATA.get("account", "public")
+    granularity = request.DATA.get("granularity", "hours")
+    slugs = request.DATA.get("slugs")
+
+    check_view_permissions(request, account)
+
+    # Fetch the values using our new method
+    result = metrics.fetch_values(slugs, when, granularity, account=account)
+    result['status'] = True
+
+    return JsonResponse(result)
+
+
+@md.POST('series', docs=SERIES_POST_DOCS)
+@md.requires_params("slugs")
+def on_metrics_series_post(request):
+    """
+    POST version of the series endpoint - same functionality as GET.
+    """
+    return on_metrics_series(request)
+
+
+# Simple value storage endpoints
+@md.POST('value/set', docs=SET_VALUE_DOCS)
+@md.requires_params("slug", "value")
+def on_set_value(request):
+    """
+    Set a simple global value (not time-series).
+    """
+    slug = request.DATA.get("slug")
+    value = request.DATA.get("value")
+    account = request.DATA.get("account", "public")
+
+    check_write_permissions(request, account)
+
+    metrics.set_value(slug, value, account=account)
+
+    return JsonResponse({
+        "slug": slug,
+        "value": value,
+        "account": account,
+        "status": True
+    })
+
+
+@md.GET('value/get', docs=VALUE_GET_DOCS)
+@md.requires_params("slugs")
+def on_get_value(request):
+    """
+    Get simple global values for multiple slugs (not time-series).
+    """
+    slugs = request.DATA.get("slugs")
+    account = request.DATA.get("account", "public")
+    default = request.DATA.get("default")
+
+    check_view_permissions(request, account)
+
+    # Handle comma-separated string input
+    if isinstance(slugs, str):
+        if ',' in slugs:
+            slugs_list = [s.strip() for s in slugs.split(',')]
+        else:
+            slugs_list = [slugs]
+    else:
+        slugs_list = slugs
+
+    # Fetch values for all slugs
+    data = {}
+    for slug in slugs_list:
+        value = metrics.get_value(slug, account=account, default=default)
+        data[slug] = value
+
+    return JsonResponse({
+        "data": data,
+        "slugs": slugs_list,
+        "account": account,
+        "status": True
+    })

mojo/apps/metrics/utils.py

@@ -34,8 +34,8 @@ GRANULARITY_OFFSET_MAP = {
 
 GRANULARITY_END_MAP = {
     'minutes': timedelta(minutes=29),
-    'hours': timedelta(hours=11),
-    'days': timedelta(days=11),
+    'hours': timedelta(hours=24),
+    'days': timedelta(days=30),
     'weeks': timedelta(weeks=11),
     'months': timedelta(days=12*30),
     'years': timedelta(days=11*360)
@@ -179,6 +179,23 @@ def generate_perm_write_key(account):
 def generate_perm_view_key(account):
     return f"mets:{account}:perm:v"
 
+def generate_accounts_key():
+    return f"mets:_accounts_"
+
+def generate_value_key(slug, account):
+    """
+    Generate a Redis key for storing simple key-value pairs.
+
+    Args:
+        slug (str): The slug identifier for the value.
+        account (str): The account under which the value is stored.
+
+    Returns:
+        str: The Redis key for the value.
+    """
+    normalized_slug = normalize_slug(slug)
+    return f"mets:{account}:val:{normalized_slug}"
+
 
 def normalize_slug(slug):
     return slug.replace(':', '|')

mojo/decorators/auth.py

@@ -1,5 +1,8 @@
 from functools import wraps
 import mojo.errors
+from mojo.helpers import logit
+
+logger = logit.get_logger("error", "error.log")
 
 def requires_perms(*required_perms):
     def decorator(func):
@@ -7,7 +10,9 @@ def requires_perms(*required_perms):
         def wrapper(request, *args, **kwargs):
             if not request.user.is_authenticated:
                 raise mojo.errors.PermissionDeniedException()
-            if not request.user.has_permission(required_perms):
+            perms = set(required_perms)
+            if not request.user.has_permission(perms):
+                logger.error(f"{request.user.username} is missing {perms}")
                 raise mojo.errors.PermissionDeniedException()
             return func(request, *args, **kwargs)
         return wrapper

mojo/decorators/http.py

@@ -10,6 +10,7 @@ from mojo.helpers.response import JsonResponse
 from functools import wraps
 from mojo.helpers import modules
 from mojo.models import rest
+from django.http import HttpResponse
 from mojo.apps import metrics
 
 logger = logit.get_logger("error", "error.log")
@@ -23,6 +24,7 @@ MOJO_APPEND_SLASH = settings.get("MOJO_APPEND_SLASH", False)
 
 API_METRICS = settings.get("API_METRICS", False)
 API_METRICS_GRANULARITY = settings.get("API_METRICS_GRANULARITY", "days")
+EVENTS_ON_ERRORS = settings.get("EVENTS_ON_ERRORS", True)
 
 
 def dispatcher(request, *args, **kwargs):
@@ -32,7 +34,19 @@ def dispatcher(request, *args, **kwargs):
     rest.ACTIVE_REQUEST = request
     key = kwargs.pop('__mojo_rest_root_key__', None)
     if "group" in request.DATA:
-        request.group = modules.get_model_instance("account", "Group", int(request.DATA.group))
+        try:
+            request.group = modules.get_model_instance("account", "Group", int(request.DATA.group))
+            if request.group is not None:
+                request.group.touch()
+        except ValueError:
+            if EVENTS_ON_ERRORS:
+                rest.MojoModel.class_report_incident(
+                    details=f"Permission denied: Invalid group ID -> '{request.DATA.group}'",
+                    event_type="rest_error",
+                    request=request,
+                    request_path=getattr(request, "path", None),
+                )
+            return JsonResponse({"error": "Invalid group ID", "code": 400}, status=400)
     method_key = f"{key}__{request.method}"
     if method_key not in URLPATTERN_METHODS:
         method_key = f"{key}__ALL"
@@ -51,22 +65,52 @@ def dispatch_error_handler(func):
         try:
             if API_METRICS:
                 metrics.record("api_calls", category="mojo_api", min_granularity=API_METRICS_GRANULARITY)
-            return func(request, *args, **kwargs)
+            resp = func(request, *args, **kwargs)
+            if not isinstance(resp, HttpResponse) and isinstance(resp, dict):
+                return JsonResponse(resp)
+            return resp
         except mojo.errors.MojoException as err:
             if API_METRICS:
                 metrics.record("api_errors", category="mojo_api", min_granularity=API_METRICS_GRANULARITY)
+            if EVENTS_ON_ERRORS:
+                rest.MojoModel.class_report_incident_for_user(
+                    details=f"Rest Mojo Error: {err.reason}",
+                    event_type="rest_error",
+                    request_data=request.DATA,
+                    request=request,
+                    request_path=getattr(request, "path", None),
+                    stack_trace=traceback.format_exc(),
+                )
             return JsonResponse({"error": err.reason, "code": err.code}, status=err.status)
         except ValueError as err:
             if API_METRICS:
                 metrics.record("api_errors", category="mojo_api", min_granularity=API_METRICS_GRANULARITY)
             logger.exception(f"ValueErrror: {str(err)}, Path: {request.path}, IP: {request.META.get('REMOTE_ADDR')}")
+            if EVENTS_ON_ERRORS:
+                rest.MojoModel.class_report_incident_for_user(
+                    details=f"Rest Value Error: {err}",
+                    event_type="rest_error",
+                    request_data=request.DATA,
+                    request=request,
+                    request_path=getattr(request, "path", None),
+                    stack_trace=traceback.format_exc()
+                )
             return JsonResponse({"error": str(err), "code": 555 }, status=500)
         except Exception as err:
             if API_METRICS:
                 metrics.record("api_errors", category="mojo_api", min_granularity=API_METRICS_GRANULARITY)
             # logger.exception(f"Unhandled REST Exception: {request.path}")
             logger.exception(f"Error: {str(err)}, Path: {request.path}, IP: {request.META.get('REMOTE_ADDR')}")
-            return JsonResponse({"error": str(err) }, status=500)
+            if EVENTS_ON_ERRORS:
+                rest.MojoModel.class_report_incident_for_user(
+                    details=f"Rest Exception: {err}",
+                    event_type="rest_error",
+                    request_data=request.DATA,
+                    request=request,
+                    stack_trace=traceback.format_exc(),
+                    request_path=getattr(request, "path", None),
+                )
+            return JsonResponse({"error": str(err), "code": 500 }, status=500)
 
     return wrapper
 

mojo/helpers/aws/__init__.py

@@ -0,0 +1,45 @@
+"""
+AWS Helpers Module
+
+A simple interface for working with AWS services.
+"""
+
+# Import service modules - these will be implemented
+from .s3 import S3Bucket, S3Item
+from .client import get_session
+from .kms import KMSHelper
+
+# These will be implemented in future modules
+from .iam import IAMRole, IAMPolicy, IAMUser
+from .ses import EmailSender, EmailTemplate
+from .sns import SNSTopic, SNSSubscription
+from .ec2 import EC2Instance, EC2SecurityGroup
+
+__all__ = [
+    # Base
+    'get_session',
+
+    # S3
+    'S3Bucket',
+    'S3Item',
+
+    # KMS
+    'KMSHelper',
+
+    # IAM
+    'IAMRole',
+    'IAMPolicy',
+    'IAMUser',
+
+    # SES
+    'EmailSender',
+    'EmailTemplate',
+
+    # SNS
+    'SNSTopic',
+    'SNSSubscription',
+
+    # EC2
+    'EC2Instance',
+    'EC2SecurityGroup',
+]