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

mojo/apps/fileman/models/manager.py

@@ -1,8 +1,10 @@
 import os
+import boto3
+from botocore.exceptions import ClientError
 from django.db import models
 from mojo.models import MojoModel, MojoSecrets
 from urllib.parse import urlparse
-
+from mojo.helpers.settings import settings
 
 class FileManager(MojoSecrets, MojoModel):
     """
@@ -13,6 +15,7 @@ class FileManager(MojoSecrets, MojoModel):
         CAN_SAVE = CAN_CREATE = True
         CAN_DELETE = True
         DEFAULT_SORT = "-id"
+        POST_SAVE_ACTIONS = ["test_connection", "fix_cors", "clone", "check_cors"]
         VIEW_PERMS = ["view_fileman", "manage_files"]
         SEARCH_FIELDS = ["name", "backend_type", "description"]
         SEARCH_TERMS = [
@@ -21,17 +24,19 @@ class FileManager(MojoSecrets, MojoModel):
 
         GRAPHS = {
             "default": {
+                "extra": ["aws_region", "aws_key", "aws_secret_masked", "allowed_origins"],
                 "fields": [
                     "created", "id", "name", "backend_type", "backend_url",
-                    "settings", "is_active", "is_default"],
+                    "is_active", "is_default"],
                 "graphs": {
                     "user": "basic",
                     "group": "basic"
                 }
             },
             "list": {
+                "extra": ["aws_region", "aws_key", "aws_secret_masked", "allowed_origins"],
                 "fields": ["created", "id", "name", "backend_type",  "backend_url",
-                    "settings", "is_active", "is_default"],
+                    "is_active", "is_default"],
                 "graphs": {
                     "user": "basic",
                     "group": "basic"
@@ -198,6 +203,47 @@ class FileManager(MojoSecrets, MojoModel):
 
     _backend = None
 
+    @property
+    def aws_key(self):
+        return self.get_secret('aws_key')
+
+    @property
+    def aws_secret(self):
+        return self.get_secret('aws_secret')
+
+    @property
+    def aws_secret_masked(self):
+        secret = self.get_secret('aws_secret', '')
+        if len(secret) > 4:
+            return '*' * (len(secret) - 4) + secret[-4:]
+        return secret
+
+    @property
+    def aws_region(self):
+        return self.get_secret('aws_region')
+
+    @property
+    def is_verified(self):
+        return self.status in ["verified", "ready"]
+
+    def set_aws_key(self, key):
+        self.set_secret('aws_key', key)
+
+    def set_aws_secret(self, secret):
+        self.set_secret('aws_secret', secret)
+
+    def set_aws_region(self, secret):
+        self.set_secret('aws_region', secret)
+
+    def set_allowed_origins(self, origins):
+        if isinstance(origins, str) and "," in origins:
+            origins = [origin.strip() for origin in origins.split(',')]
+        self.set_secret('allowed_origins', origins)
+
+    @property
+    def allowed_origins(self):
+        return self.get_secret('allowed_origins')
+
     @property
     def backend(self):
         """Get the backend instance"""
@@ -282,6 +328,13 @@ class FileManager(MojoSecrets, MojoModel):
         self._update_default()
         if not self.name:
             self.name = self.generate_name()
+        if created:
+            if not self.aws_region:
+                self.set_aws_region(settings.get("AWS_REGION", "us-east-1"))
+            if not self.aws_key:
+                self.set_aws_key(settings.get("AWS_KEY", None))
+            if not self.aws_secret:
+                self.set_aws_secret(settings.get("AWS_SECRET", None))
         if created or "is_default" in changed_fields:
             self._update_default()
 
@@ -304,6 +357,219 @@ class FileManager(MojoSecrets, MojoModel):
             return f"{self.group.name}'s {self.backend_type} FileManager"
         return f"{self.backend_type} FileManager"
 
+    def on_action_test_connection(self, value):
+        try:
+            self.backend.test_connection()
+            return dict(status=True)
+        except Exception as e:
+            return dict(status=False, error=str(e))
+
+    def on_action_fix_cors(self, value):
+        try:
+            if not self.is_s3:
+                return dict(status=False, error="CORS management is only supported for S3 backends.")
+            # Validate connectivity first
+            self.backend.test_connection()
+            allowed_origins = self._resolve_allowed_origins_from_value_or_settings(value or {})
+            result = self.update_cors(allowed_origins)
+            return dict(status=True, result=result)
+        except Exception as e:
+            return dict(status=False, error=str(e))
+
+    def on_action_check_cors(self, value):
+        try:
+            if not self.is_s3:
+                return dict(status=False, error="CORS management is only supported for S3 backends.")
+            self.backend.test_connection()
+            # allowed_origins = self._resolve_allowed_origins_from_value_or_settings(value or {})
+            result = self.check_cors_config(allowed_origins=self.allowed_origins)
+            return dict(status=True, result=result)
+        except Exception as e:
+            return dict(status=False, error=str(e))
+
+    def on_action_clone(self, value):
+        secrets = self.secrets
+        new_manager = FileManager(user=self.user, group=self.group)
+        new_manager.name = f"Clone of {self.name}"
+        new_manager.backend_url = self.backend_url
+        new_manager.backend_type = self.backend_type
+        new_manager.set_secrets(secrets)
+        new_manager.save()
+        return dict(status=True, id=new_manager.id)
+
+    def fix_cors(self):
+        """
+        Ensure bucket CORS allows direct uploads from configured origins.
+        This uses manager settings and does not require manual AWS console changes.
+        """
+        if not self.is_s3:
+            return
+        allowed_origins = self._resolve_allowed_origins_from_value_or_settings({})
+        self.update_cors(allowed_origins)
+
+    # --- CORS helpers for S3 direct upload ---
+    def _s3_client(self):
+        if not self.is_s3:
+            raise ValueError("CORS management is only supported for S3 backends.")
+        session = boto3.Session(
+            aws_access_key_id=self.aws_key,
+            aws_secret_access_key=self.aws_secret,
+            region_name=self.aws_region or "us-east-1",
+        )
+        endpoint_url = self.get_setting("endpoint_url", None)
+        return session.client("s3", endpoint_url=endpoint_url)
+
+    def _resolve_allowed_origins_from_value_or_settings(self, value):
+        """
+        Resolve a list of allowed origins from action value or global settings.
+        Accepts 'origins', 'allowed_origins', 'domains', or 'list_of_domains' keys.
+        Falls back to settings such as CORS_ALLOWED_ORIGINS, ALLOWED_ORIGINS, FRONTEND_ORIGIN/URL.
+        """
+        origins = []
+
+        if isinstance(value, dict):
+            for key in ("origins", "allowed_origins", "domains", "list_of_domains"):
+                v = value.get(key)
+                if v:
+                    if isinstance(v, str):
+                        origins.extend([s.strip() for s in v.split(",") if s.strip()])
+                    elif isinstance(v, (list, tuple)):
+                        origins.extend([str(s).strip() for s in v if str(s).strip()])
+                    break
+
+        for key in ("CORS_ALLOWED_ORIGINS", "ALLOWED_ORIGINS"):
+            v = settings.get(key)
+            if v:
+                if isinstance(v, str):
+                    origins.extend([s.strip() for s in v.split(",") if s.strip()])
+                elif isinstance(v, (list, tuple)):
+                    origins.extend([str(s).strip() for s in v if str(s).strip()])
+
+        for key in ("FRONTEND_ORIGIN", "FRONTEND_URL", "SITE_URL", "BASE_URL"):
+            v = settings.get(key)
+            if v:
+                origins.append(str(v).strip())
+
+        # Normalize: dedupe, drop trailing slash
+        cleaned = []
+        seen = set()
+        for o in origins:
+            if not o:
+                continue
+            if o.endswith("/"):
+                o = o[:-1]
+            if o not in seen:
+                seen.add(o)
+                cleaned.append(o)
+
+        if not cleaned:
+            raise ValueError("No allowed origins provided. Please pass at least one origin.")
+        return cleaned
+
+    def check_cors_config(self, allowed_origins=None, required_methods=None, required_headers=None):
+        """
+        Check the current CORS configuration to ensure it supports direct uploads.
+        Note: S3 CORS is bucket-wide. Prefix-level restriction must be enforced by IAM/policy and presigned URLs.
+        """
+        if not self.is_s3:
+            raise ValueError("CORS management is only supported for S3 backends.")
+
+        s3 = self._s3_client()
+        bucket = self.root_location
+
+        try:
+            resp = s3.get_bucket_cors(Bucket=bucket)
+            config = resp
+        except ClientError as e:
+            if e.response.get("Error", {}).get("Code") == "NoSuchCORSConfiguration":
+                return {"ok": False, "issues": ["No CORS configuration set on this bucket."], "config": None}
+            return {"ok": False, "issues": [str(e)], "config": None}
+
+        if allowed_origins is None:
+            allowed_origins = self._resolve_allowed_origins_from_value_or_settings({})
+        if not allowed_origins:
+            raise ValueError("No allowed origins provided. Please pass at least one origin.")
+
+        required_methods = [m.upper() for m in (required_methods or ["GET", "PUT", "POST", "HEAD"])]
+        required_headers = [h.lower() for h in (required_headers or ["content-type"])]
+
+        rules = config.get("CORSRules", [])
+        issues = []
+
+        def origin_covered(origin: str) -> bool:
+            for r in rules:
+                origins = r.get("AllowedOrigins", [])
+                if "*" in origins or origin in origins:
+                    methods = [m.upper() for m in r.get("AllowedMethods", [])]
+                    if not all(m in methods for m in required_methods):
+                        continue
+                    headers = [h.lower() for h in r.get("AllowedHeaders", [])]
+                    if "*" in headers or all(h in headers for h in required_headers):
+                        return True
+            return False
+
+        for origin in allowed_origins:
+            if not origin_covered(origin):
+                issues.append(f"Origin not covered for direct upload: {origin}")
+
+        return {"ok": len(issues) == 0, "issues": issues, "config": config}
+
+    def update_cors(self, allowed_origins, merge=True, allowed_methods=None, allowed_headers=None, expose_headers=None, max_age_seconds=3000):
+        """
+        Update bucket CORS to support direct uploads from allowed_origins.
+        If merge=True, append our rule to any existing rules; otherwise replace entirely.
+        """
+        if not self.is_s3:
+            raise ValueError("CORS management is only supported for S3 backends.")
+
+        s3 = self._s3_client()
+        bucket = self.root_location
+        if not allowed_origins:
+            raise ValueError("No allowed origins provided. Please pass at least one origin.")
+
+        if allowed_methods is None:
+            allowed_methods = ["POST", "HEAD"] if getattr(self.backend, "server_side_encryption", None) else ["PUT", "HEAD"]
+        allowed_methods = [m.upper() for m in allowed_methods]
+        allowed_headers = [h for h in (allowed_headers or ["*"])]
+        expose_headers = expose_headers or ["ETag", "x-amz-request-id", "x-amz-id-2", "x-amz-version-id"]
+
+        desired = {
+            "CORSRules": [
+                {
+                    "AllowedOrigins": allowed_origins,
+                    "AllowedMethods": allowed_methods,
+                    "AllowedHeaders": allowed_headers,
+                    "ExposeHeaders": expose_headers,
+                    "MaxAgeSeconds": max_age_seconds,
+                }
+            ]
+        }
+
+        # If already compliant, no change
+        verify_required_headers = [] if getattr(self.backend, "server_side_encryption", None) else ["content-type"]
+        check = self.check_cors_config(allowed_origins, required_methods=allowed_methods, required_headers=verify_required_headers)
+        if check["ok"]:
+            return {"changed": False, "message": "Existing CORS already supports direct uploads.", "current": check["config"]}
+
+        current = None
+        try:
+            current = s3.get_bucket_cors(Bucket=bucket)
+        except ClientError as e:
+            if e.response.get("Error", {}).get("Code") != "NoSuchCORSConfiguration":
+                raise
+
+        if merge and current:
+            merged = {"CORSRules": current.get("CORSRules", []) + desired["CORSRules"]}
+            s3.put_bucket_cors(Bucket=bucket, CORSConfiguration=merged)
+            applied = merged
+        else:
+            s3.put_bucket_cors(Bucket=bucket, CORSConfiguration=desired)
+            applied = desired
+
+        verify_required_headers = [] if getattr(self.backend, "server_side_encryption", None) else ["content-type"]
+        verify = self.check_cors_config(allowed_origins, required_methods=allowed_methods, required_headers=verify_required_headers)
+        return {"changed": True, "applied": applied, "verified": verify["ok"], "post_update_issues": verify["issues"]}
+
     @classmethod
     def get_from_request(cls, request):
         """Get the file manager from the request"""

mojo/apps/incident/migrations/0007_event_uid.py

@@ -0,0 +1,18 @@
+# Generated by Django 4.2.21 on 2025-08-29 18:04
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('incident', '0006_alter_incident_state'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='event',
+            name='uid',
+            field=models.IntegerField(db_index=True, default=None, null=True),
+        ),
+    ]

mojo/apps/incident/migrations/0008_ticket_ticketnote.py

@@ -0,0 +1,55 @@
+# Generated by Django 4.2.21 on 2025-08-30 02:36
+
+from django.conf import settings
+from django.db import migrations, models
+import django.db.models.deletion
+import mojo.models.rest
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('fileman', '0011_alter_filerendition_original_file'),
+        ('account', '0011_user_org_registereddevice_pushconfig_and_more'),
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+        ('incident', '0007_event_uid'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='Ticket',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('created', models.DateTimeField(auto_now_add=True)),
+                ('modified', models.DateTimeField(auto_now=True)),
+                ('title', models.CharField(max_length=255)),
+                ('description', models.TextField(blank=True, null=True)),
+                ('status', models.CharField(db_index=True, default='open', max_length=50)),
+                ('priority', models.IntegerField(db_index=True, default=1)),
+                ('metadata', models.JSONField(blank=True, default=dict)),
+                ('assignee', models.ForeignKey(blank=True, default=None, null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='assigned_tickets', to=settings.AUTH_USER_MODEL)),
+                ('group', models.ForeignKey(blank=True, default=None, null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='+', to='account.group')),
+                ('incident', models.ForeignKey(blank=True, default=None, null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='tickets', to='incident.incident')),
+                ('user', models.ForeignKey(blank=True, default=None, null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='+', to=settings.AUTH_USER_MODEL)),
+            ],
+            options={
+                'ordering': ['-created'],
+            },
+            bases=(models.Model, mojo.models.rest.MojoModel),
+        ),
+        migrations.CreateModel(
+            name='TicketNote',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('created', models.DateTimeField(auto_now_add=True)),
+                ('note', models.TextField(blank=True, null=True)),
+                ('author', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='+', to=settings.AUTH_USER_MODEL)),
+                ('media', models.ForeignKey(blank=True, default=None, null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='+', to='fileman.file')),
+                ('parent', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='notes', to='incident.ticket')),
+            ],
+            options={
+                'ordering': ['-created'],
+            },
+            bases=(models.Model, mojo.models.rest.MojoModel),
+        ),
+    ]

mojo/apps/incident/migrations/0009_incident_status.py

@@ -0,0 +1,18 @@
+# Generated by Django 4.2.23 on 2025-09-05 22:03
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('incident', '0008_ticket_ticketnote'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='incident',
+            name='status',
+            field=models.CharField(db_index=True, default='open', max_length=50),
+        ),
+    ]

mojo/apps/incident/migrations/0010_event_country_code.py

@@ -0,0 +1,18 @@
+# Generated by Django 4.2.23 on 2025-09-05 22:22
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('incident', '0009_incident_status'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='event',
+            name='country_code',
+            field=models.CharField(db_index=True, default=None, max_length=2, null=True),
+        ),
+    ]

mojo/apps/incident/migrations/0011_incident_country_code.py

@@ -0,0 +1,18 @@
+# Generated by Django 4.2.23 on 2025-09-05 22:25
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('incident', '0010_event_country_code'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='incident',
+            name='country_code',
+            field=models.CharField(db_index=True, default=None, max_length=2, null=True),
+        ),
+    ]

mojo/apps/incident/migrations/0012_alter_incident_status.py

@@ -0,0 +1,18 @@
+# Generated by Django 4.2.23 on 2025-09-06 00:00
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('incident', '0011_incident_country_code'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='incident',
+            name='status',
+            field=models.CharField(db_index=True, default='new', max_length=50),
+        ),
+    ]

mojo/apps/incident/models/__init__.py

@@ -2,3 +2,4 @@ from .event import Event
 from .rule import RuleSet, Rule
 from .incident import Incident
 from .history import IncidentHistory
+from .ticket import Ticket, TicketNote

mojo/apps/incident/models/event.py

@@ -4,6 +4,7 @@ from mojo.models import MojoModel
 from mojo.helpers import dates
 from mojo.helpers.settings import settings
 from mojo.apps import metrics
+from mojo.apps.account.models import GeoLocatedIP
 
 
 INCIDENT_LEVEL_THRESHOLD = settings.get('INCIDENT_LEVEL_THRESHOLD', 7)
@@ -22,6 +23,8 @@ class Event(models.Model, MojoModel):
     category = models.CharField(max_length=124, db_index=True)
     source_ip = models.CharField(max_length=16, null=True, default=None, db_index=True)
     hostname = models.CharField(max_length=16, null=True, default=None, db_index=True)
+    uid = models.IntegerField(default=None, null=True, db_index=True)
+    country_code = models.CharField(max_length=2, default=None, null=True, db_index=True)
 
     title = models.TextField(default=None, null=True)
     details = models.TextField(default=None, null=True)
@@ -40,6 +43,16 @@ class Event(models.Model, MojoModel):
         VIEW_PERMS = ["view_incidents"]
         CREATE_PERMS = None
 
+    _geo_ip = None
+    @property
+    def geo_ip(self):
+        if self._geo_ip is None and self.source_ip:
+            try:
+                self._geo_ip = GeoLocatedIP.geolocate(self.source_ip, subdomain_only=True)
+            except Exception:
+                pass
+        return self._geo_ip
+
     def sync_metadata(self):
         # Gather all field values into the metadata
         field_values = {
@@ -50,6 +63,17 @@ class Event(models.Model, MojoModel):
             'details': self.details,
             'model_name': self.model_name,
             'model_id': self.model_id        }
+
+        if not self.country_code and self.geo_ip:
+            self.country_code = self.geo_ip.country_code
+            field_values["country_code"] = self.geo_ip.country_code
+            field_values["country_name"] = self.geo_ip.country_name
+            field_values["city"] = self.geo_ip.city
+            field_values["region"] = self.geo_ip.region
+            field_values["latitude"] = self.geo_ip.latitude
+            field_values["longitude"] = self.geo_ip.longitude
+            field_values["timezone"] = self.geo_ip.timezone
+
         # Update the metadata with these values
         self.metadata.update(field_values)
 
@@ -69,11 +93,21 @@ class Event(models.Model, MojoModel):
         if settings.INCIDENT_EVENT_METRICS:
             metrics.record('incident_events', account="incident",
                 min_granularity=settings.get("INCIDENT_METRICS_MIN_GRANULARITY", "hours"))
+            if self.country_code:
+                metrics.record(f'incident_events:country:{self.country_code}',
+                    account="incident",
+                    category="incident_events_by_country",
+                    min_granularity=settings.get("INCIDENT_METRICS_MIN_GRANULARITY", "hours"))
 
     def record_incident_metrics(self):
         if settings.INCIDENT_EVENT_METRICS:
             metrics.record('incidents', account="incident",
                 min_granularity=settings.get("INCIDENT_METRICS_MIN_GRANULARITY", "hours"))
+            if self.country_code:
+                metrics.record(f'incident:country:{self.country_code}',
+                    account="incident",
+                    category="incidents_by_country",
+                    min_granularity=settings.get("INCIDENT_METRICS_MIN_GRANULARITY", "hours"))
 
     def get_or_create_incident(self, rule_set=None):
         """
@@ -94,6 +128,7 @@ class Event(models.Model, MojoModel):
                 priority=self.level,
                 state=0,
                 category=self.category,
+                country_code=self.country_code,
                 title=self.title,
                 details=self.details,
                 hostname=self.hostname,

mojo/apps/incident/models/incident.py

@@ -10,7 +10,9 @@ class Incident(models.Model, MojoModel):
 
     priority = models.IntegerField(default=0, db_index=True)
     state = models.CharField(max_length=24, default=0, db_index=True)
+    status = models.CharField(max_length=50, default='new', db_index=True)
     category = models.CharField(max_length=124, db_index=True)
+    country_code = models.CharField(max_length=2, default=None, null=True, db_index=True)
     title = models.TextField(default=None, null=True)
     details = models.TextField(default=None, null=True)
 

mojo/apps/incident/models/ticket.py

@@ -0,0 +1,62 @@
+from django.db import models
+from mojo.models import MojoModel
+
+
+class Ticket(models.Model, MojoModel):
+    class Meta:
+        ordering = ['-created']
+
+    class RestMeta:
+        VIEW_PERMS = ['view_incidents']
+        SAVE_PERMS = ['manage_incidents']
+        GRAPHS = {
+            "default": {
+                "graphs": {
+                    "assignee": "basic",
+                    "incident": "basic",
+                    "user": "basic",
+                    "group": "basic"
+                }
+            },
+        }
+
+    created = models.DateTimeField(auto_now_add=True, editable=False)
+    modified = models.DateTimeField(auto_now=True)
+
+    user = models.ForeignKey("account.User", blank=True, null=True, default=None, related_name="+", on_delete=models.SET_NULL)
+    group = models.ForeignKey("account.Group", blank=True, null=True, default=None, related_name="+", on_delete=models.SET_NULL)
+
+    title = models.CharField(max_length=255)
+    description = models.TextField(blank=True, null=True)
+
+    status = models.CharField(max_length=50, default='open', db_index=True)
+    priority = models.IntegerField(default=1, db_index=True)
+
+    assignee = models.ForeignKey("account.User", blank=True, null=True, default=None, related_name="assigned_tickets", on_delete=models.SET_NULL)
+    incident = models.ForeignKey("incident.Incident", blank=True, null=True, default=None, related_name="tickets", on_delete=models.SET_NULL)
+
+    metadata = models.JSONField(default=dict, blank=True)
+
+
+class TicketNote(models.Model, MojoModel):
+    class Meta:
+        ordering = ['-created']
+
+    class RestMeta:
+        VIEW_PERMS = ['view_incidents']
+        SAVE_PERMS = ['manage_incidents']
+        GRAPHS = {
+            "default": {
+                "graphs": {
+                    "author": "basic",
+                    "media": "basic"
+                }
+            },
+        }
+
+    parent = models.ForeignKey(Ticket, related_name="notes", on_delete=models.CASCADE)
+    created = models.DateTimeField(auto_now_add=True, editable=False)
+
+    author = models.ForeignKey("account.User", related_name="+", on_delete=models.CASCADE)
+    note = models.TextField(blank=True, null=True)
+    media = models.ForeignKey("fileman.File", related_name="+", null=True, blank=True, default=None, on_delete=models.SET_NULL)

mojo/apps/incident/reporter.py

@@ -1,7 +1,7 @@
 
 
 # TODO make this async using our task queue
-async def report_event(details, title=None, category="api_error", level=1, request=None, **kwargs):
+def report_event(details, title=None, category="api_error", level=1, request=None, **kwargs):
     from .models import Event
     event_data = _create_event_dict(details, title, category, level, request, **kwargs)
     event = Event(**event_data)
@@ -19,6 +19,7 @@ def _create_event_dict(details, title=None, category="api_error", level=1, reque
         "title": title,
         "category": category,
         "level": level,
+        "uid": kwargs.pop("uid", None),
         "hostname": kwargs.pop("hostname", None),
         "model_name": kwargs.pop("model_name", None),
         "model_id": kwargs.pop("model_id", None),
@@ -38,7 +39,24 @@ def _create_event_dict(details, title=None, category="api_error", level=1, reque
             "http_user_agent": request.META.get("HTTP_USER_AGENT", ""),
             "http_host": request.META.get("HTTP_HOST", "")
         })
-
-    event_metadata.update({k: v for k, v in kwargs.items() if k not in event_data})
+        if request.user.is_authenticated:
+            event_data["uid"] = request.user.id
+            event_metadata["user_name"] = request.user.display_name
+            event_metadata["user_email"] = request.user.email
+
+    processed_kwargs = {}
+    for k, v in kwargs.items():
+        if k not in event_data:
+            if is_json_serializable(v):
+                processed_kwargs[k] = v
+            elif hasattr(v, 'id'):
+                processed_kwargs[k] = v.id
+            else:
+                processed_kwargs[k] = str(v)
+
+    event_metadata.update(processed_kwargs)
     event_data['metadata'] = event_metadata
     return event_data
+
+def is_json_serializable(value):
+    return isinstance(value, (str, int, float, bool, type(None), list, dict))