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

mojo/apps/fileman/signals.py

@@ -0,0 +1,58 @@
+import logging
+from django.db.models.signals import post_save, post_delete
+from django.dispatch import receiver
+from mojo.apps.fileman.models import File
+from mojo.apps.fileman.tasks import process_file_renditions, cleanup_renditions
+
+logger = logging.getLogger(__name__)
+
+@receiver(post_save, sender=File)
+def handle_file_upload_completed(sender, instance, created, **kwargs):
+    """
+    When a file is marked as completed, automatically create renditions
+    
+    This connects to the post_save signal of the File model and checks if the
+    file has been marked as completed. If so, it queues a task to create renditions.
+    """
+    # Only process if the file upload is completed
+    if instance.is_completed:
+        # Check if this is a status change to completed
+        if not created:
+            try:
+                # Get the previous instance from the database
+                old_instance = sender.objects.get(pk=instance.pk)
+                if old_instance.upload_status != instance.upload_status and instance.upload_status == File.COMPLETED:
+                    logger.info(f"File {instance.id} ({instance.filename}) marked as completed, creating renditions")
+                    # Queue task to create renditions
+                    process_file_renditions.delay(instance.id)
+            except Exception as e:
+                logger.error(f"Error checking file status change: {str(e)}")
+        else:
+            # For new files that are already completed
+            if instance.upload_status == File.COMPLETED:
+                logger.info(f"New file {instance.id} ({instance.filename}) is completed, creating renditions")
+                # Queue task to create renditions
+                process_file_renditions.delay(instance.id)
+
+@receiver(post_delete, sender=File)
+def handle_file_deleted(sender, instance, **kwargs):
+    """
+    When a file is deleted, clean up its renditions
+    
+    This connects to the post_delete signal of the File model and ensures that
+    when a file is deleted, its renditions are also removed from storage.
+    """
+    try:
+        # Check if we have any renditions to clean up
+        from mojo.apps.fileman.models import FileRendition
+        if FileRendition.objects.filter(original_file_id=instance.id).exists():
+            logger.info(f"File {instance.id} ({instance.filename}) deleted, cleaning up renditions")
+            # Queue task to clean up renditions
+            # Note: We can't use instance.id directly in the task since the object is being deleted
+            # So we pass the ID value
+            cleanup_renditions.delay(instance.id)
+    except Exception as e:
+        logger.error(f"Error queueing rendition cleanup for deleted file: {str(e)}")
+
+# Note: No need to manually connect signals as Django will automatically
+# discover and connect properly decorated signal handlers

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/models/__init__.py

@@ -1,3 +1,4 @@
 from .event import Event
 from .rule import RuleSet, Rule
 from .incident import Incident
+from .history import IncidentHistory

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,7 +9,7 @@ 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)
     category = models.CharField(max_length=124, db_index=True)
     title = models.TextField(default=None, null=True)
     details = models.TextField(default=None, null=True)

mojo/apps/incident/reporter.py

@@ -1,5 +1,7 @@
 
-def report_event(details, title=None, category="api_error", level=1, request=None, **kwargs):
+
+# TODO make this async using our task queue
+async 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)

mojo/apps/incident/rest/event.py

@@ -1,5 +1,5 @@
 from mojo import decorators as md
-from mojo.apps.incident.models import Incident, Event, RuleSet, Rule
+from mojo.apps.incident.models import Incident, IncidentHistory, Event, RuleSet, Rule
 
 
 @md.URL('incident')
@@ -7,6 +7,12 @@ from mojo.apps.incident.models import Incident, Event, RuleSet, Rule
 def on_incident(request, pk=None):
     return Incident.on_rest_request(request, pk)
 
+@md.URL('incident/history')
+@md.URL('incident/<int:pk>/history')
+def on_incident_history(request, pk=None):
+    return IncidentHistory.on_rest_request(request, pk)
+
+
 @md.URL('event')
 @md.URL('event/<int:pk>')
 def on_event(request, pk=None):

mojo/apps/logit/migrations/0004_alter_log_level.py

@@ -0,0 +1,18 @@
+# Generated by Django 4.2.21 on 2025-08-26 16:05
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('logit', '0003_log_level'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='log',
+            name='level',
+            field=models.CharField(db_index=True, default='info', max_length=12),
+        ),
+    ]

mojo/apps/logit/models/log.py

@@ -29,6 +29,7 @@ class Log(dm.Model, MojoModel):
         log = logit.mask_sensitive_data(log)
 
         uid, username, ip_address, path, method, duid = 0, None, None, None, None, None
+        user_agent = "system"
         if request:
             username = request.user.username if request.user.is_authenticated else None
             uid = request.user.pk if request.user.is_authenticated else 0
@@ -36,6 +37,7 @@ class Log(dm.Model, MojoModel):
             duid = request.duid
             ip_address = request.ip
             method = request.method
+            user_agent = request.user_agent
 
         path = kwargs.get("path", path)
         method = kwargs.get("method", method)
@@ -46,12 +48,13 @@ class Log(dm.Model, MojoModel):
             kind=kind,
             method=method,
             path=path,
+            payload=kwargs.get("payload", None),
             ip=ip_address,
             uid=uid,
             duid=duid,
             username=username,
             log=log,
-            user_agent=request.user_agent,
+            user_agent=user_agent,
             model_name=model_name,
             model_id=model_id
         )

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)

mojo/apps/notify/handlers/ses/message.py

@@ -40,7 +40,7 @@ def on_raw_email(request, imsg, msg_data):
     to_email = imsg.receipt.recipients[0]
     # logger.info("parsed", msg_data)
     msg = createMessage(to_email, msg_data)
-    metrics.metric("emails_received", category="email", min_granularity="hourly")
+    metrics.metric("emails_received", category="email", min_granularity="hours")
 
     attachments = []
     for msg_atch in msg_data.attachments:

mojo/apps/notify/providers/aws.py

@@ -31,11 +31,11 @@ def send_mail_via_ses(msg, sender, recipients, fail_silently=True):
             RawMessage={'Data': msg.as_string()}
         )
         if EMAIL_METRICS:
-            metrics.record("emails_sent", category="email", min_granularity="hourly")
+            metrics.record("emails_sent", category="email", min_granularity="hours")
         return True
     except Exception as err:
         if EMAIL_METRICS:
-            metrics.record("email_errors", category="email", min_granularity="hourly")
+            metrics.record("email_errors", category="email", min_granularity="hours")
         EMAIL_LOGGER.exception(err)
         EMAIL_LOGGER.error(msg.as_string())
         if not fail_silently:

mojo/apps/tasks/__init__.py

@@ -1,11 +1,44 @@
 from mojo.helpers.settings import settings
+from mojo.helpers import modules
+import functools
 
 
 def get_manager():
     from .manager import TaskManager
-    return TaskManager(settings.TASKIT_CHANNELS)
+    return TaskManager(settings.TASK_CHANNELS)
 
 
 def publish(channel, function, data, expires=1800):
     man = get_manager()
     return man.publish(function, data, channel=channel, expires=expires)
+
+
+def async_task(channel="bg_tasks", expires=1800):
+    def decorator(func):
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            # Check if this is being called from the task queue
+            # If '_from_task_queue' is in kwargs and True, execute directly without publishing
+            from_task_queue = kwargs.pop('_from_task_queue', False)
+
+            if from_task_queue:
+                # Execute the original function directly when called from task queue
+                from mojo.helpers import logit
+                logit.get_logger("debug", "debug.log").info(f"executing directly {args} {kwargs}")
+                return func(*args, **kwargs)
+            else:
+                # Generate function string as "<module_name>.<function_name>"
+                function_string = f"{func.__module__}.{func.__name__}"
+
+                # Generate data from args and kwargs
+                data = {
+                    'args': list(args),
+                    'kwargs': {**kwargs, '_from_task_queue': True}  # Add flag for task queue
+                }
+
+                # Publish the task
+                publish(channel=channel, function=function_string, data=data, expires=expires)
+
+                return True
+        return wrapper
+    return decorator