Django ORM-Based Sequence Generation for Invoices

Let me address your questions about implementing a custom sequence generator for invoice numbers in Django:

1. Scalability and Reliability Under Concurrency

Your Django ORM-based approach using select_for_update() within an atomic transaction is reliable for preventing duplicate IDs under high concurrency. The select_for_update() method acquires a row-level lock, ensuring that only one process can modify the sequence at a time, which prevents race conditions.

This approach is scalable for most use cases, but there are some considerations:

• The row-level lock can become a bottleneck under extremely high concurrency
• Each invoice creation requires two database operations (read and update the sequence)
• The transaction overhead might impact performance in high-throughput scenarios

However, for most invoice applications, this approach should be sufficient as invoice generation typically isn't a high-frequency operation compared to other database activities.

2. Supporting Bulk Operations

Extending this concept to support bulk_create() or bulk_update() requires careful handling since these operations are designed to minimize database queries. Here's an approach:

PYTHONCopied
@classmethod
def get_next_numbers(cls, sequence_name, count):
    with transaction.atomic():
        sequence = cls.objects.select_for_update().get(name=sequence_name)
        start_number = sequence.sequence_number + 1
        sequence.sequence_number += count
        sequence.save()
        return range(start_number, start_number + count)

# Usage with bulk_create
def create_invoices_in_bulk(invoice_data_list):
    with transaction.atomic():
        # Get sequence numbers for all invoices at once
        count = len(invoice_data_list)
        numbers = ControlSequence.get_next_numbers('invoice', count)
        
        # Create invoice objects with assigned numbers
        invoices = []
        for i, data in enumerate(invoice_data_list):
            prefix = ControlSequence.objects.get(name='invoice').prefix
            invoice_number = f"{prefix}-{numbers[i]:04d}"
            invoice = Invoice(invoice_number=invoice_number, **data)
            invoices.append(invoice)
        
        # Bulk create the invoices
        return Invoice.objects.bulk_create(invoices)

This approach:

1. Gets a batch of sequence numbers in a single transaction
2. Assigns them to the objects before bulk creation
3. Maintains the efficiency of bulk operations while ensuring unique numbers

3. Best Practices for Django Admin

For handling this in the Django admin portal:

1. Override the save_model method in your ModelAdmin class:

PYTHONCopied
class InvoiceAdmin(admin.ModelAdmin):
    def save_model(self, request, obj, form, change):
        if not change:  # Only for new invoices
            if not obj.invoice_number:
                next_number = ControlSequence.get_next_number('invoice')
                prefix = ControlSequence.objects.get(name='invoice').prefix
                obj.invoice_number = f"{prefix}-{next_number:04d}"
        super().save_model(request, obj, form, change)

2. Make the invoice_number field read-only for existing records:

PYTHONCopied
class InvoiceAdmin(admin.ModelAdmin):
    def get_readonly_fields(self, request, obj=None):
        if obj:  # Editing an existing object
            return self.readonly_fields + ('invoice_number',)
        return self.readonly_fields

3. For bulk actions, implement a custom admin action:

PYTHONCopied
@admin.action(description="Generate invoice numbers for selected invoices")
def generate_invoice_numbers(modeladmin, request, queryset):
    with transaction.atomic():
        count = queryset.filter(invoice_number__isnull=True).count()
        if count > 0:
            numbers = ControlSequence.get_next_numbers('invoice', count)
            prefix = ControlSequence.objects.get(name='invoice').prefix
            
            i = 0
            for invoice in queryset.filter(invoice_number__isnull=True):
                invoice.invoice_number = f"{prefix}-{numbers[i]:04d}"
                invoice.save()
                i += 1

This approach provides a robust solution for managing invoice numbers in Django while maintaining the benefits of your custom sequence generator.