django-nativemojo 0.1.10__py3-none-any.whl

mojo/helpers/request_parser.py

@@ -0,0 +1,269 @@
+import ujson
+from typing import Any, Dict, List
+from django.http import QueryDict
+from objict import objict, nobjict
+
+
+class RequestDataParser:
+    """
+    A robust parser for Django request data that consolidates GET, POST, JSON, and FILES
+    into a single objict with support for dotted notation and array handling.
+    """
+
+    def __init__(self, use_objict=True):
+        """
+        Initialize parser.
+
+        Args:
+            use_objict: Whether to use objict() or regular dict() for nested structures
+        """
+        self.dict_factory = objict if use_objict else dict
+
+    def parse(self, request) -> 'objict':
+        """
+        Main entry point - parses all request data into a single objict.
+
+        Args:
+            request: Django HttpRequest object
+
+        Returns:
+            objict containing all parsed request data
+        """
+        result = self.dict_factory()
+
+        # Process in order of precedence (later sources can override earlier ones)
+        self._process_query_params(request.GET, result)
+        self._process_form_data(request, result)
+        self._process_json_data(request, result)
+        self._process_files(request.FILES, result)
+
+        return result
+
+    def _process_query_params(self, query_dict: QueryDict, target: 'objict') -> None:
+        """Process GET parameters from QueryDict."""
+        if not query_dict:
+            return
+
+        for key in query_dict.keys():
+            values = query_dict.getlist(key)
+            normalized_key = self._normalize_key(key)
+            self._set_nested_value(target, normalized_key, values)
+
+    def _process_form_data(self, request, target: 'objict') -> None:
+        """Process POST form data (non-JSON requests)."""
+        if request.method not in {'POST', 'PUT', 'PATCH', 'DELETE'}:
+            return
+
+        # Skip if this is a JSON request
+        content_type = getattr(request, 'content_type', '').lower()
+        if 'application/json' in content_type:
+            return
+
+        if not request.POST:
+            return
+
+        for key in request.POST.keys():
+            values = request.POST.getlist(key)
+            normalized_key = self._normalize_key(key)
+            self._set_nested_value(target, normalized_key, values)
+
+    def _process_json_data(self, request, target: 'objict') -> None:
+        """Process JSON request body."""
+        if request.method not in {'POST', 'PUT', 'PATCH', 'DELETE'}:
+            return
+
+        content_type = getattr(request, 'content_type', '').lower()
+        if 'application/json' not in content_type:
+            return
+
+        try:
+            if hasattr(request, 'body') and request.body:
+                json_data = ujson.loads(request.body.decode('utf-8'))
+                if isinstance(json_data, dict):
+                    self._merge_dict_data(json_data, target)
+                else:
+                    # Handle case where JSON root is not an object
+                    target['_json_data'] = json_data
+        except Exception as e:
+            # Store error info for debugging
+            target['_json_parse_error'] = str(e)
+
+    def _process_files(self, files_dict, target: 'objict') -> None:
+        """Process uploaded files."""
+        if not files_dict:
+            return
+
+        files_obj = nobjict()
+
+        for key in files_dict.keys():
+            files = files_dict.getlist(key)
+            normalized_key = self._normalize_key(key)
+
+            # Store single file directly, multiple files as list
+            file_value = files[0] if len(files) == 1 else files
+            self._set_nested_value(files_obj, normalized_key, [file_value])
+
+        if files_obj:
+            target['files'] = files_obj
+
+    def _normalize_key(self, key: str) -> str:
+        """
+        Normalize keys by removing array notation brackets.
+
+        Examples:
+            'tags[]' -> 'tags'
+            'user[name][]' -> 'user.name'
+            'items[0][name]' -> 'items.0.name'
+        """
+        # Remove trailing []
+        key = key.rstrip('[]')
+
+        # Convert bracket notation to dot notation
+        # user[name] -> user.name
+        # items[0][name] -> items.0.name
+        import re
+        key = re.sub(r'\[([^\]]+)\]', r'.\1', key)
+
+        return key
+
+    def _merge_dict_data(self, source: Dict[str, Any], target: 'objict') -> None:
+        """Recursively merge dictionary data into target objict."""
+        for key, value in source.items():
+            self._set_nested_value(target, key, [value])
+
+    def _set_nested_value(self, target: 'objict', dotted_key: str, values: List[Any]) -> None:
+        """
+        Set a value in nested objict structure using dotted key notation.
+
+        Args:
+            target: Target objict to modify
+            dotted_key: Key like 'user.profile.name' or 'tags'
+            values: List of values (handles single values and arrays)
+        """
+        if not dotted_key:
+            return
+
+        parts = dotted_key.split('.')
+        current = target
+
+        # Navigate to the parent of the final key
+        for part in parts[:-1]:
+            if not part:  # Skip empty parts from double dots
+                continue
+
+            if part not in current:
+                current[part] = self.dict_factory()
+            elif not isinstance(current[part], (dict, objict, nobjict)):
+                # Convert existing non-dict value to dict to avoid conflicts
+                current[part] = self.dict_factory()
+
+            current = current[part]
+
+        final_key = parts[-1]
+        if not final_key:  # Handle edge case of trailing dot
+            return
+
+        # Determine final value based on number of values
+        if len(values) == 0:
+            final_value = None
+        elif len(values) == 1:
+            final_value = values[0]
+        else:
+            final_value = values
+
+        # Handle existing values - merge into arrays if needed
+        if final_key in current:
+            existing = current[final_key]
+            if isinstance(existing, list):
+                if isinstance(final_value, list):
+                    existing.extend(final_value)
+                else:
+                    existing.append(final_value)
+            else:
+                if isinstance(final_value, list):
+                    current[final_key] = [existing] + final_value
+                else:
+                    current[final_key] = [existing, final_value]
+        else:
+            current[final_key] = final_value
+
+
+# Convenience functions for backward compatibility
+def parse_request_data(request) -> 'objict':
+    """
+    Parse Django request data into a single objict.
+
+    Args:
+        request: Django HttpRequest object
+
+    Returns:
+        objict containing all parsed request data
+    """
+    parser = RequestDataParser()
+    return parser.parse(request)
+
+
+def parse_request_data_debug(request) -> 'objict':
+    """
+    Parse request data with debug information printed.
+    """
+    print("=== REQUEST PARSING DEBUG ===")
+    print(f"Method: {request.method}")
+    print(f"Content-Type: {getattr(request, 'content_type', 'Not set')}")
+    print(f"GET keys: {list(request.GET.keys())}")
+    print(f"POST keys: {list(request.POST.keys())}")
+    print(f"FILES keys: {list(request.FILES.keys())}")
+
+    if hasattr(request, 'body'):
+        body_preview = request.body[:200] if request.body else b''
+        print(f"Body preview: {body_preview}")
+
+    result = parse_request_data(request)
+    print(f"Parsed result keys: {list(result.keys())}")
+    print("=== END DEBUG ===")
+
+    return result
+
+
+# Example usage and test cases
+def test_parser():
+    """
+    Test function to demonstrate parser capabilities.
+    """
+    from django.http import QueryDict
+    from io import StringIO
+    import sys
+
+    # Capture output for testing
+    old_stdout = sys.stdout
+    sys.stdout = buffer = StringIO()
+
+    try:
+        # Mock request object for testing
+        class MockRequest:
+            def __init__(self):
+                self.method = 'POST'
+                self.content_type = 'application/json'
+                self.GET = QueryDict('user.name=John&tags[]=python&tags[]=django&user.age=30')
+                self.POST = QueryDict()
+                self.FILES = QueryDict()
+                self.body = b'{"api_key": "secret", "nested": {"value": 42}}'
+
+        request = MockRequest()
+        result = parse_request_data(request)
+
+        print("Test Results:")
+        print(f"User name: {result.get('user', {}).get('name')}")
+        print(f"User age: {result.get('user', {}).get('age')}")
+        print(f"Tags: {result.get('tags')}")
+        print(f"API Key: {result.get('api_key')}")
+        print(f"Nested value: {result.get('nested', {}).get('value')}")
+
+    finally:
+        sys.stdout = old_stdout
+        output = buffer.getvalue()
+        print(output)
+
+
+if __name__ == "__main__":
+    test_parser()

mojo/helpers/response.py

@@ -0,0 +1,14 @@
+import ujson
+from django.http import HttpResponse
+
+
+class JsonResponse(HttpResponse):
+    def __init__(self, data, status=200, safe=True, **kwargs):
+        if safe and not isinstance(data, dict):
+            raise TypeError(
+                'In order to allow non-dict objects to be serialized set the '
+                'safe parameter to False.'
+            )
+        kwargs.setdefault('content_type', 'application/json')
+        data = ujson.dumps(data)
+        super().__init__(content=data, status=status, **kwargs)

mojo/helpers/settings.py

@@ -0,0 +1,146 @@
+import importlib
+from typing import Any, Union
+
+UNKNOWN = Ellipsis
+
+
+def load_settings_profile(context):
+    from mojo.helpers import modules, paths
+    # Set default profile
+    profile = "local"
+    # Check if a profile file exists and override profile
+    profile_file = paths.VAR_ROOT / "profile"
+    if profile_file.exists():
+        with open(profile_file, 'r') as file:
+            profile = file.read().strip()
+    modules.load_module_to_globals("settings.defaults", context)
+    modules.load_module_to_globals(f"settings.{profile}", context)
+
+def load_settings_config(context):
+    # Load config from django.conf file
+    from mojo.helpers import paths
+    config_path = paths.VAR_ROOT / "django.conf"
+    if not config_path.exists():
+        raise Exception(f"Required configuration file not found: {config_path}")
+
+    with open(config_path, 'r') as file:
+        for line in file:
+            if '=' in line:
+                key, value = line.strip().split('=', 1)
+                value = value.strip()
+                if value.startswith('"') and value.endswith('"'):
+                    value = value[1:-1]
+                elif value.startswith("'") and value.endswith("'"):
+                    value = value[1:-1]
+                if value.startswith('f"') or value.startswith("f'"):
+                    value = eval(value)
+                elif value.lower() == 'true':
+                    value = True
+                elif value.lower() == 'false':
+                    value = False
+                else:
+                    try:
+                        if '.' in value:
+                            value = float(value)
+                        else:
+                            value = int(value)
+                    except ValueError:
+                        pass
+                context[key.strip()] = value
+
+    if context.get("ALLOW_ADMIN_SITE", True):
+        if "django.contrib.admin" not in context["INSTALLED_APPS"]:
+            context["INSTALLED_APPS"].insert(0, "django.contrib.admin")
+
+
+class SettingsHelper:
+    """
+    A helper class for accessing Django settings with support for:
+    - Default values if settings are missing.
+    - App-specific settings loading from `{app_name}.settings`.
+    - Dictionary-style (`settings["KEY"]`) and attribute-style (`settings.KEY`) access.
+    """
+
+    def __init__(self, root_settings=None, defaults=None):
+        """
+        Initialize the settings helper.
+
+        :param root_settings: The primary settings source (Django settings or a dictionary).
+        :param defaults: An optional defaults module or dictionary.
+        """
+        self.root = root_settings
+        self.defaults = defaults
+        self._app_cache = {}
+
+    def load_settings(self):
+        from django.conf import settings as django_settings
+        self.root = django_settings
+
+    def get_app_settings(self, app_name: str) -> "SettingsHelper":
+        """
+        Get settings for a specific app, attempting to load `{app_name}.settings`.
+
+        :param app_name: The Django app name.
+        :return: A `SettingsHelper` instance for the app settings.
+        """
+        key = f"{app_name.upper()}_SETTINGS"
+
+        if key in self._app_cache:
+            return self._app_cache[key]
+
+        try:
+            app_defaults = importlib.import_module(f"{app_name}.settings")
+        except ModuleNotFoundError:
+            app_defaults = {}
+
+        self._app_cache[key] = SettingsHelper(self.get(key, {}), app_defaults)
+        return self._app_cache[key]
+
+    def get(self, name: str, default: Any = UNKNOWN) -> Any:
+        """
+        Retrieve a setting, falling back to defaults if needed.
+
+        :param name: The setting name.
+        :param default: The default value if the setting is not found.
+        :return: The setting value or the provided default.
+        """
+        if self.root is None:
+            self.load_settings()
+        if isinstance(self.root, dict):
+            value = self.root.get(name, UNKNOWN)
+        else:
+            value = getattr(self.root, name, UNKNOWN)
+
+        return value if value is not UNKNOWN else self.get_default(name, default)
+
+    def get_default(self, name: str, default: Any = None) -> Any:
+        """
+        Retrieve a setting from the defaults, if provided.
+
+        :param name: The setting name.
+        :param default: The default value if the setting is not found in defaults.
+        :return: The default setting value.
+        """
+        if isinstance(self.defaults, dict):
+            return self.defaults.get(name, default)
+
+        return getattr(self.defaults, name, default)
+
+    def is_app_installed(self, app_label):
+        return app_label in self.get("INSTALLED_APPS")
+
+    def __getattr__(self, name: str) -> Any:
+        """
+        Access settings as attributes (`settings.KEY`).
+        """
+        return self.get(name, None)
+
+    def __getitem__(self, key: str) -> Any:
+        """
+        Access settings as dictionary keys (`settings["KEY"]`).
+        """
+        return self.get(key)
+
+
+# Create a global settings helper for accessing Django settings
+settings = SettingsHelper()

mojo/helpers/sysinfo.py

@@ -0,0 +1,140 @@
+import platform
+import socket
+
+from datetime import datetime
+import time
+
+try:
+    import psutil
+except ImportError:
+    psutil = None
+
+
+def get_host_ip():
+    """Get the IP address associated with the current hostname."""
+    hostname = socket.gethostname()
+    return socket.gethostbyname(hostname)
+
+def get_tcp_established_count():
+    """Return the count of established TCP connections."""
+    return len(get_tcp_established())
+
+def get_tcp_established(filter_type=None):
+    """
+    Get a list of established TCP connections, optionally filtering by type.
+
+    :param filter_type: Optionally filter by type ('https', 'redis', 'postgres', etc.)
+    :return: List of connections according to filter
+    """
+    connections = psutil.net_connections(kind="tcp")
+    established_connections = [c for c in connections if c.status == psutil.CONN_ESTABLISHED]
+    return filter_connections(established_connections, filter_type)
+
+def filter_connections(connections, filter_type):
+    """
+    Filter connections based on the specified filter type.
+
+    :param connections: List of connections
+    :param filter_type: Type to filter (options: 'https', 'redis', 'postgres')
+    :return: List of filtered connections
+    """
+    filters = {
+        "https": lambda c: c.laddr.port == 443,
+        "redis": lambda c: c.raddr.port == 6379,
+        "postgres": lambda c: c.raddr.port == 5432,
+        "unknown": lambda c: c.raddr.port not in [5432, 6379] and c.laddr.port != 443
+    }
+
+    if filter_type in filters:
+        return [c for c in connections if filters[filter_type](c)]
+    elif filter_type and ":" in filter_type:
+        addr, port = filter_type.split(':')
+        port = int(port)
+        return [c for c in connections if (addr == "raddr" and c.raddr.port == port) or (addr == "laddr" and c.laddr.port == port)]
+
+    return connections
+
+def connections_to_dict(connections):
+    """
+    Convert a list of connections to a dictionary representation.
+
+    :param connections: List of connections
+    :return: List of dictionaries representing connections
+    """
+    return [
+        {
+            "id": idx,
+            "type": c.type.name,
+            "status": c.status,
+            "family": c.family.name,
+            "raddr": {
+                "port": c.raddr.port if c.raddr else None,
+                "ip": c.raddr.ip if c.raddr else None,
+            },
+            "laddr": {
+                "port": c.laddr.port,
+                "ip": c.laddr.ip
+            }
+        }
+        for idx, c in enumerate(connections, start=1)
+    ]
+
+
+def get_host_info(include_versions=False, include_blocked=False):
+    """
+    Gather information about the host.
+
+    :param include_versions: Include software versions if True
+    :param include_blocked: Include blocked hosts if True
+    :return: Dictionary with host information
+    """
+    mem = psutil.virtual_memory()
+    disk = psutil.disk_usage('/')
+    net = psutil.net_io_counters()
+
+    host_info = {
+        "time": time.time(),
+        "datetime": datetime.now().isoformat(),
+        "version": version.VERSION,  # check if this needs to be imported correctly or version info retrieval needs adaptation
+        "os": {
+            "system": platform.system(),
+            "version": platform.version(),
+            "hostname": platform.node(),
+            "release": platform.release(),
+            "processor": platform.processor(),
+            "machine": platform.machine()
+        },
+        "boot_time": psutil.boot_time(),
+        "cpu_load": psutil.cpu_percent(),
+        "cpus_load": psutil.cpu_percent(percpu=True),
+        "memory": {
+            "total": mem.total,
+            "used": mem.used,
+            "available": mem.available,
+            "percent": mem.percent
+        },
+        "disk": {
+            "total": disk.total,
+            "used": disk.used,
+            "free": disk.free,
+            "percent": disk.percent
+        },
+        "users": psutil.users(),
+        "cpu": {
+            "count": psutil.cpu_count(),
+            "freq": psutil.cpu_freq()._asdict() if psutil.cpu_freq() else None,
+        },
+        "network": {
+            "tcp_cons": get_tcp_established_count(),
+            "bytes_sent": net.bytes_sent,
+            "bytes_recv": net.bytes_recv,
+            "packets_sent": net.packets_sent,
+            "packets_recv": net.packets_recv,
+            "errin": net.errin,
+            "errout": net.errout,
+            "dropin": net.dropin,
+            "dropout": net.dropout
+        }
+    }
+
+    return host_info

mojo/middleware/auth.py

@@ -0,0 +1,26 @@
+from django.utils.deprecation import MiddlewareMixin
+# from django.http import JsonResponse
+from mojo.helpers.response import JsonResponse
+from mojo.apps.account.utils.jwtoken import JWToken
+from mojo.apps.account.models.user import User
+from mojo.helpers import request as rhelper
+from mojo.helpers.request import get_user_agent
+from objict import objict
+
+
+
+class AuthenticationMiddleware(MiddlewareMixin):
+    def process_request(self, request):
+        token = request.META.get('HTTP_AUTHORIZATION', None)
+        if token is None:
+            return
+        prefix, token = token.split()
+        request.auth_token = objict(prefix=prefix, token=token)
+        if prefix.lower() != 'bearer':
+            return
+        # decode data to find the user
+        user, error = User.validate_jwt(token)
+        if error is not None:
+            return JsonResponse({'error': error}, status=401)
+        request.user = user
+        user.touch()

mojo/middleware/logging.py

@@ -0,0 +1,55 @@
+from mojo.apps.logit.models import Log
+from mojo.helpers.settings import settings
+from mojo.helpers import logit
+from mojo.helpers.response import JsonResponse
+
+API_PREFIX = "/".join([settings.get("MOJO_PREFIX", "api/").rstrip("/"), ""])
+LOGIT_DB_ALL = settings.get("LOGIT_DB_ALL", False)
+LOGIT_FILE_ALL = settings.get("LOGIT_FILE_ALL", False)
+LOGIT_RETURN_REAL_ERROR = settings.get("LOGIT_RETURN_REAL_ERROR", True)
+LOGGER = logit.get_logger("requests", "requests.log")
+ERROR_LOGGER = logit.get_logger("error", "error.log")
+LOGIT_NO_LOG_PREFIX = settings.get("LOGIT_NO_LOG_PREFIX", [])
+
+class LoggerMiddleware:
+    def __init__(self, get_response):
+        self.get_response = get_response
+
+    def __call__(self, request):
+        # Log the request before calling get_response
+        self.log_request(request)
+        try:
+            response = self.get_response(request)
+        except Exception as e:
+            # Log or store the exception here
+            err = ERROR_LOGGER.exception()
+            Log.logit(request, err, "api_error")
+            error = "system error"
+            if LOGIT_RETURN_REAL_ERROR:
+                error = str(e)
+            response = JsonResponse(dict(status=False, error=error), status=500)
+        # Log the response after get_response has been called
+        self.log_response(request, response)
+        return response
+
+    def can_log(self, request):
+        prefixes = LOGIT_NO_LOG_PREFIX
+        if not isinstance(prefixes, (list, set, tuple)) or not prefixes:
+            return True
+        return not any(request.path.startswith(prefix) for prefix in prefixes)
+
+    def log_request(self, request):
+        if not self.can_log(request):
+            return
+        if LOGIT_DB_ALL:
+            request.request_log = Log.logit(request, request.DATA.to_json(as_string=True), "request")
+        if LOGIT_FILE_ALL:
+            LOGGER.info(f"REQUEST - {request.method} - {request.ip} - {request.path}", request.body)
+
+    def log_response(self, request, response):
+        if not self.can_log(request):
+            return
+        if LOGIT_DB_ALL:
+            Log.logit(request, response.content, "response")
+        if LOGIT_FILE_ALL:
+            LOGGER.info(f"RESPONSE - {request.method} - {request.ip} - {request.path}", response.content)

mojo/middleware/mojo.py

@@ -0,0 +1,21 @@
+from mojo.helpers import request as rhelper
+import time
+from objict import objict
+
+ANONYMOUS_USER = objict(is_authenticated=False)
+
+
+class MojoMiddleware:
+    def __init__(self, get_response):
+        self.get_response = get_response
+
+    def __call__(self, request):
+        request.started_at = time.time()
+        request.user = ANONYMOUS_USER
+        request.group = None
+        request.request_log = None
+        request.ip = rhelper.get_remote_ip(request)
+        request.user_agent = rhelper.get_user_agent(request)
+        request.duid = rhelper.get_device_id(request)
+        request.DATA = rhelper.parse_request_data(request)
+        return self.get_response(request)