Preventing Accidental Bulk Operations in Django

To safeguard against accidental bulk operations that could update or delete all rows in a table, you can create a custom manager for your models that overrides the default update() and delete() methods to add safety checks. Here's an effective approach:

Custom Manager Solution

PYTHONCopied
from django.db import models
from django.core.exceptions import PermissionDenied

class SafeQuerySet(models.QuerySet):
    def update(self, **kwargs):
        # Check if the queryset is filtered
        if not self.query.where:
            raise PermissionDenied("Bulk update without filters is not allowed")
        return super().update(**kwargs)
    
    def delete(self):
        # Check if the queryset is filtered
        if not self.query.where:
            raise PermissionDenied("Bulk delete without filters is not allowed")
        return super().delete()

class SafeManager(models.Manager):
    def get_queryset(self):
        return SafeQuerySet(self.model, using=self._db)

# Example usage in your models
class MyModel(models.Model):
    name = models.CharField(max_length=100)
    
    # Replace the default manager
    objects = SafeManager()
    
    # Optionally keep the default manager under a different name
    unsafe_objects = models.Manager()

With this implementation:

1. MyModel.objects.update(field=xxx) will raise a PermissionDenied exception
2. MyModel.objects.delete() will raise a PermissionDenied exception
3. Filtered operations like MyModel.objects.filter(id=1).update(field=xxx) will work normally

Alternative Approaches

1. Using Database Transactions

For critical operations, wrap them in transactions and verify the count before committing:

PYTHONCopied
from django.db import transaction

with transaction.atomic():
    queryset = MyModel.objects.all()
    count = queryset.count()
    if count > 10:  # Set your threshold
        raise Exception(f"Operation would affect {count} rows, which exceeds the limit")
    queryset.update(field=xxx)

2. Custom Middleware

For a project-wide solution, you could implement middleware that logs or restricts certain database operations based on your criteria.

Important Considerations

• The custom manager approach is the most robust as it enforces the rule at the model level
• Remember that if you need to perform legitimate bulk operations, you can still use the unsafe_objects manager
• This solution doesn't affect Django admin operations, which might still perform bulk operations

This approach provides a good balance between safety and flexibility, allowing you to prevent accidental bulk operations while still maintaining the ability to perform them when necessary.