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

mojo/apps/fileman/tasks.py

@@ -0,0 +1,254 @@
+import logging
+from celery import shared_task
+from mojo.apps.fileman.models import File, FileRendition
+from mojo.apps.fileman.renderer import process_new_file, get_renderer_for_file
+
+logger = logging.getLogger(__name__)
+
+@shared_task
+def process_file_renditions(file_id):
+    """
+    Process renditions for a newly uploaded file
+    
+    Args:
+        file_id: ID of the File to process
+    
+    Returns:
+        dict: Result information including number of renditions created
+    """
+    try:
+        file = File.objects.get(id=file_id)
+        
+        if not file.is_completed:
+            logger.warning(f"Cannot process renditions for incomplete file {file_id}")
+            return {
+                'status': 'error',
+                'message': 'File upload is not complete',
+                'file_id': file_id,
+                'renditions_created': 0
+            }
+        
+        renditions = process_new_file(file)
+        
+        return {
+            'status': 'success',
+            'message': f'Created {len(renditions)} renditions',
+            'file_id': file_id,
+            'renditions_created': len(renditions),
+            'rendition_roles': [r.role for r in renditions]
+        }
+        
+    except File.DoesNotExist:
+        logger.error(f"File with ID {file_id} not found")
+        return {
+            'status': 'error',
+            'message': 'File not found',
+            'file_id': file_id,
+            'renditions_created': 0
+        }
+    except Exception as e:
+        logger.exception(f"Error processing renditions for file {file_id}: {str(e)}")
+        return {
+            'status': 'error',
+            'message': str(e),
+            'file_id': file_id,
+            'renditions_created': 0
+        }
+
+@shared_task
+def cleanup_renditions(file_id):
+    """
+    Clean up all renditions for a file
+    
+    Args:
+        file_id: ID of the File whose renditions should be cleaned up
+    
+    Returns:
+        dict: Result information
+    """
+    try:
+        # First get the file to make sure it exists
+        file = File.objects.get(id=file_id)
+        
+        # Get all renditions
+        renditions = FileRendition.objects.filter(original_file_id=file_id)
+        count = renditions.count()
+        
+        # Delete the files from storage
+        for rendition in renditions:
+            try:
+                if rendition.storage_path:
+                    file.file_manager.backend.delete(rendition.storage_path)
+            except Exception as e:
+                logger.warning(f"Error deleting rendition file {rendition.id}: {str(e)}")
+        
+        # Delete the database records
+        renditions.delete()
+        
+        return {
+            'status': 'success',
+            'message': f'Cleaned up {count} renditions',
+            'file_id': file_id,
+            'renditions_deleted': count
+        }
+        
+    except File.DoesNotExist:
+        logger.error(f"File with ID {file_id} not found")
+        return {
+            'status': 'error',
+            'message': 'File not found',
+            'file_id': file_id,
+            'renditions_deleted': 0
+        }
+    except Exception as e:
+        logger.exception(f"Error cleaning up renditions for file {file_id}: {str(e)}")
+        return {
+            'status': 'error',
+            'message': str(e),
+            'file_id': file_id,
+            'renditions_deleted': 0
+        }
+
+@shared_task
+def regenerate_renditions(file_id, roles=None):
+    """
+    Regenerate specific or all renditions for a file
+    
+    Args:
+        file_id: ID of the File to process
+        roles: Optional list of roles to regenerate (None for all)
+    
+    Returns:
+        dict: Result information
+    """
+    try:
+        file = File.objects.get(id=file_id)
+        
+        if not file.is_completed:
+            logger.warning(f"Cannot regenerate renditions for incomplete file {file_id}")
+            return {
+                'status': 'error',
+                'message': 'File upload is not complete',
+                'file_id': file_id,
+                'renditions_created': 0
+            }
+        
+        # Get renderer for this file
+        renderer = get_renderer_for_file(file)
+        if not renderer:
+            return {
+                'status': 'error',
+                'message': f'No renderer available for file type {file.category}',
+                'file_id': file_id,
+                'renditions_created': 0
+            }
+        
+        # If specific roles are requested, delete and regenerate those
+        if roles:
+            # Delete existing renditions for these roles
+            FileRendition.objects.filter(original_file=file, role__in=roles).delete()
+            
+            # Create new renditions
+            created_renditions = []
+            for role in roles:
+                rendition = renderer.create_rendition(role)
+                if rendition:
+                    created_renditions.append(rendition)
+        else:
+            # Delete all existing renditions
+            FileRendition.objects.filter(original_file=file).delete()
+            
+            # Create all default renditions
+            created_renditions = renderer.create_all_renditions()
+        
+        return {
+            'status': 'success',
+            'message': f'Regenerated {len(created_renditions)} renditions',
+            'file_id': file_id,
+            'renditions_created': len(created_renditions),
+            'rendition_roles': [r.role for r in created_renditions]
+        }
+        
+    except File.DoesNotExist:
+        logger.error(f"File with ID {file_id} not found")
+        return {
+            'status': 'error',
+            'message': 'File not found',
+            'file_id': file_id,
+            'renditions_created': 0
+        }
+    except Exception as e:
+        logger.exception(f"Error regenerating renditions for file {file_id}: {str(e)}")
+        return {
+            'status': 'error',
+            'message': str(e),
+            'file_id': file_id,
+            'renditions_created': 0
+        }
+
+@shared_task
+def process_bulk_renditions(file_ids, roles=None):
+    """
+    Process renditions for multiple files
+    
+    Args:
+        file_ids: List of File IDs to process
+        roles: Optional list of roles to generate (None for all default roles)
+    
+    Returns:
+        dict: Result information
+    """
+    results = {
+        'total': len(file_ids),
+        'successful': 0,
+        'failed': 0,
+        'errors': []
+    }
+    
+    for file_id in file_ids:
+        try:
+            file = File.objects.get(id=file_id)
+            
+            if not file.is_completed:
+                results['failed'] += 1
+                results['errors'].append({
+                    'file_id': file_id,
+                    'error': 'File upload is not complete'
+                })
+                continue
+            
+            renderer = get_renderer_for_file(file)
+            if not renderer:
+                results['failed'] += 1
+                results['errors'].append({
+                    'file_id': file_id,
+                    'error': f'No renderer for file type {file.category}'
+                })
+                continue
+            
+            if roles:
+                renditions = []
+                for role in roles:
+                    rendition = renderer.get_rendition(role)
+                    if rendition:
+                        renditions.append(rendition)
+            else:
+                renditions = renderer.create_all_renditions()
+            
+            results['successful'] += 1
+            
+        except File.DoesNotExist:
+            results['failed'] += 1
+            results['errors'].append({
+                'file_id': file_id,
+                'error': 'File not found'
+            })
+        except Exception as e:
+            results['failed'] += 1
+            results['errors'].append({
+                'file_id': file_id,
+                'error': str(e)
+            })
+            logger.exception(f"Error processing renditions for file {file_id}: {str(e)}")
+    
+    return results

mojo/apps/fileman/utils/__init__.py

@@ -1,19 +1,43 @@
 # File upload utility functions
 
-from .upload import (
-    get_file_manager,
-    validate_file_request,
-    initiate_upload,
-    finalize_upload,
-    direct_upload,
-    get_download_url
-)
+# from .upload import (
+#     get_file_manager,
+#     validate_file_request,
+#     initiate_upload,
+#     finalize_upload,
+#     direct_upload,
+#     get_download_url
+# )
 
-__all__ = [
-    'get_file_manager',
-    'validate_file_request',
-    'initiate_upload',
-    'finalize_upload',
-    'direct_upload',
-    'get_download_url'
-]
+def get_file_category(content_type: str) -> str:
+    if not content_type:
+        return "unknown"
+
+    content_type = content_type.lower()
+
+    if content_type.startswith("image/"):
+        return "image"
+    elif content_type.startswith("video/"):
+        return "video"
+    elif content_type.startswith("audio/"):
+        return "audio"
+    elif content_type == "application/pdf":
+        return "pdf"
+    elif content_type in ["text/csv", "application/csv"]:
+        return "csv"
+    elif content_type in [
+        "application/vnd.ms-excel",
+        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+    ]:
+        return "spreadsheet"
+    elif content_type in [
+        "application/msword",
+        "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+    ]:
+        return "document"
+    elif content_type in ["application/zip", "application/x-zip-compressed"]:
+        return "archive"
+    elif content_type.startswith("text/"):
+        return "text"
+    else:
+        return "other"

mojo/apps/incident/migrations/0005_incidenthistory.py

@@ -0,0 +1,39 @@
+# Generated by Django 4.2.21 on 2025-06-07 13:32
+
+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 = [
+        ('account', '0003_group_mojo_secrets_user_mojo_secrets'),
+        ('fileman', '0001_initial'),
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+        ('incident', '0004_alter_incident_model_id'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='IncidentHistory',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('created', models.DateTimeField(auto_now_add=True)),
+                ('kind', models.CharField(blank=True, db_index=True, default=None, max_length=80, null=True)),
+                ('state', models.IntegerField(default=0)),
+                ('priority', models.IntegerField(default=0)),
+                ('note', models.TextField(blank=True, default=None, null=True)),
+                ('by', models.ForeignKey(blank=True, default=None, null=True, on_delete=django.db.models.deletion.CASCADE, related_name='+', to=settings.AUTH_USER_MODEL)),
+                ('group', models.ForeignKey(blank=True, default=None, null=True, on_delete=django.db.models.deletion.CASCADE, related_name='+', to='account.group')),
+                ('media', models.ForeignKey(default=None, null=True, on_delete=django.db.models.deletion.CASCADE, related_name='+', to='fileman.file')),
+                ('parent', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='history', to='incident.incident')),
+                ('to', models.ForeignKey(blank=True, default=None, null=True, on_delete=django.db.models.deletion.CASCADE, related_name='+', to=settings.AUTH_USER_MODEL)),
+            ],
+            options={
+                'ordering': ['-created'],
+            },
+            bases=(models.Model, mojo.models.rest.MojoModel),
+        ),
+    ]

mojo/apps/incident/migrations/0006_alter_incident_state.py

@@ -0,0 +1,18 @@
+# Generated by Django 4.2.21 on 2025-06-07 14:13
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('incident', '0005_incidenthistory'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='incident',
+            name='state',
+            field=models.CharField(db_index=True, default=0, max_length=24),
+        ),
+    ]

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

@@ -1,3 +1,5 @@
 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/history.py

@@ -0,0 +1,36 @@
+from django.db import models
+from mojo.models import MojoModel
+
+class IncidentHistory(models.Model, MojoModel):
+    class Meta:
+        ordering = ['-created']
+
+    class RestMeta:
+        GRAPHS = {
+            "default": {
+                "extra": [
+                    ("get_state_display", "state_display"),
+                    ("get_priority_display", "priority_display"),
+                ],
+                "graphs": {
+                    "by": "basic",
+                    "to": "basic",
+                    "media": "basic"
+                }
+            },
+        }
+    parent = models.ForeignKey("incident.Incident", related_name="history", on_delete=models.CASCADE)
+    created = models.DateTimeField(auto_now_add=True, editable=False)
+
+    group = models.ForeignKey("account.Group", blank=True, null=True, default=None, related_name="+", on_delete=models.CASCADE)
+
+    kind = models.CharField(max_length=80, blank=True, null=True, default=None, db_index=True)
+
+    to = models.ForeignKey("account.User", blank=True, null=True, default=None, related_name="+", on_delete=models.CASCADE)
+    by = models.ForeignKey("account.User", blank=True, null=True, default=None, related_name="+", on_delete=models.CASCADE)
+
+    state = models.IntegerField(default=0)
+    priority = models.IntegerField(default=0)
+
+    note = models.TextField(blank=True, null=True, default=None)
+    media = models.ForeignKey("fileman.File", related_name="+", null=True, default=None, on_delete=models.CASCADE)

mojo/apps/incident/models/incident.py

@@ -9,8 +9,10 @@ class Incident(models.Model, MojoModel):
     created = models.DateTimeField(auto_now_add=True, editable=False, db_index=True)
 
     priority = models.IntegerField(default=0, db_index=True)
-    state = 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)