Comprehensive comparison for Backend technology in Fintech applications

from decimal import Decimal
from django.db import transaction, models
from django.core.exceptions import ValidationError
from django.utils import timezone
from rest_framework import status
from rest_framework.decorators import api_view, permission_classes
from rest_framework.permissions import IsAuthenticated
from rest_framework.response import Response
import uuid


class Account(models.Model):
    """Bank account model with balance tracking"""
    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
    user = models.ForeignKey('auth.User', on_delete=models.CASCADE)
    account_number = models.CharField(max_length=20, unique=True)
    balance = models.DecimalField(max_digits=15, decimal_places=2, default=Decimal('0.00'))
    currency = models.CharField(max_length=3, default='USD')
    is_active = models.BooleanField(default=True)
    created_at = models.DateTimeField(auto_now_add=True)


class Transaction(models.Model):
    """Transaction record for audit trail"""
    TRANSACTION_TYPES = [
        ('TRANSFER', 'Transfer'),
        ('DEPOSIT', 'Deposit'),
        ('WITHDRAWAL', 'Withdrawal')
    ]
    
    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
    from_account = models.ForeignKey(Account, on_delete=models.PROTECT, related_name='outgoing_transactions', null=True)
    to_account = models.ForeignKey(Account, on_delete=models.PROTECT, related_name='incoming_transactions')
    amount = models.DecimalField(max_digits=15, decimal_places=2)
    transaction_type = models.CharField(max_length=20, choices=TRANSACTION_TYPES)
    reference = models.CharField(max_length=100, blank=True)
    status = models.CharField(max_length=20, default='COMPLETED')
    created_at = models.DateTimeField(auto_now_add=True)


@api_view(['POST'])
@permission_classes([IsAuthenticated])
def transfer_funds(request):
    """
    API endpoint to transfer funds between accounts with atomic transaction handling.
    Ensures data consistency and implements business validations.
    """
    from_account_id = request.data.get('from_account_id')
    to_account_number = request.data.get('to_account_number')
    amount = request.data.get('amount')
    reference = request.data.get('reference', '')

    # Input validation
    if not all([from_account_id, to_account_number, amount]):
        return Response(
            {'error': 'Missing required fields'},
            status=status.HTTP_400_BAD_REQUEST
        )

    try:
        amount = Decimal(str(amount))
        if amount <= 0:
            raise ValidationError('Amount must be positive')
    except (ValueError, ValidationError) as e:
        return Response(
            {'error': f'Invalid amount: {str(e)}'},
            status=status.HTTP_400_BAD_REQUEST
        )

    # Use atomic transaction to ensure consistency
    try:
        with transaction.atomic():
            # Lock rows to prevent race conditions
            from_account = Account.objects.select_for_update().get(
                id=from_account_id,
                user=request.user,
                is_active=True
            )
            
            to_account = Account.objects.select_for_update().get(
                account_number=to_account_number,
                is_active=True
            )

            # Business validations
            if from_account.currency != to_account.currency:
                return Response(
                    {'error': 'Currency mismatch'},
                    status=status.HTTP_400_BAD_REQUEST
                )

            if from_account.balance < amount:
                return Response(
                    {'error': 'Insufficient funds'},
                    status=status.HTTP_400_BAD_REQUEST
                )

            # Perform transfer
            from_account.balance -= amount
            to_account.balance += amount
            
            from_account.save(update_fields=['balance'])
            to_account.save(update_fields=['balance'])

            # Create transaction record for audit trail
            txn = Transaction.objects.create(
                from_account=from_account,
                to_account=to_account,
                amount=amount,
                transaction_type='TRANSFER',
                reference=reference,
                status='COMPLETED'
            )

            return Response({
                'transaction_id': str(txn.id),
                'status': 'SUCCESS',
                'amount': str(amount),
                'new_balance': str(from_account.balance),
                'timestamp': txn.created_at.isoformat()
            }, status=status.HTTP_200_OK)

    except Account.DoesNotExist:
        return Response(
            {'error': 'Account not found or unauthorized'},
            status=status.HTTP_404_NOT_FOUND
        )
    except Exception as e:
        return Response(
            {'error': f'Transaction failed: {str(e)}'},
            status=status.HTTP_500_INTERNAL_SERVER_ERROR
        )