Comprehensive comparison for Backend technology in Fintech applications

from django.db import models, transaction
from django.contrib.auth.models import User
from django.core.exceptions import ValidationError
from decimal import Decimal
from rest_framework import serializers, status
from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework.permissions import IsAuthenticated
import uuid
from datetime import datetime


class Account(models.Model):
    """Bank account model with balance tracking"""
    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
    user = models.ForeignKey(User, on_delete=models.CASCADE, related_name='accounts')
    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)
    updated_at = models.DateTimeField(auto_now=True)

    class Meta:
        db_table = 'accounts'
        indexes = [models.Index(fields=['user', 'is_active'])]


class Transaction(models.Model):
    """Transaction ledger for audit trail"""
    TRANSACTION_TYPES = [('DEBIT', 'Debit'), ('CREDIT', 'Credit')]
    TRANSACTION_STATUS = [('PENDING', 'Pending'), ('COMPLETED', 'Completed'), ('FAILED', 'Failed')]
    
    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
    account = models.ForeignKey(Account, on_delete=models.PROTECT, related_name='transactions')
    transaction_type = models.CharField(max_length=10, choices=TRANSACTION_TYPES)
    amount = models.DecimalField(max_digits=15, decimal_places=2)
    status = models.CharField(max_length=10, choices=TRANSACTION_STATUS, default='PENDING')
    reference = models.CharField(max_length=100, unique=True)
    description = models.TextField()
    created_at = models.DateTimeField(auto_now_add=True)

    class Meta:
        db_table = 'transactions'
        ordering = ['-created_at']


class TransferSerializer(serializers.Serializer):
    """Serializer for fund transfer requests"""
    from_account = serializers.UUIDField()
    to_account = serializers.UUIDField()
    amount = serializers.DecimalField(max_digits=15, decimal_places=2, min_value=Decimal('0.01'))
    description = serializers.CharField(max_length=500)

    def validate(self, data):
        if data['from_account'] == data['to_account']:
            raise serializers.ValidationError("Cannot transfer to the same account")
        if data['amount'] <= 0:
            raise serializers.ValidationError("Amount must be positive")
        return data


class FundTransferAPIView(APIView):
    """API endpoint for secure fund transfers between accounts"""
    permission_classes = [IsAuthenticated]

    def post(self, request):
        serializer = TransferSerializer(data=request.data)
        if not serializer.is_valid():
            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

        data = serializer.validated_data
        
        try:
            with transaction.atomic():
                # Lock accounts to prevent race conditions
                from_account = Account.objects.select_for_update().get(
                    id=data['from_account'],
                    user=request.user,
                    is_active=True
                )
                to_account = Account.objects.select_for_update().get(
                    id=data['to_account'],
                    is_active=True
                )

                # Validate sufficient balance
                if from_account.balance < data['amount']:
                    return Response(
                        {"error": "Insufficient funds"},
                        status=status.HTTP_400_BAD_REQUEST
                    )

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

                # Generate unique reference
                reference = f"TXN-{datetime.now().strftime('%Y%m%d')}-{uuid.uuid4().hex[:8].upper()}"

                # Debit source account
                from_account.balance -= data['amount']
                from_account.save()

                Transaction.objects.create(
                    account=from_account,
                    transaction_type='DEBIT',
                    amount=data['amount'],
                    status='COMPLETED',
                    reference=reference,
                    description=data['description']
                )

                # Credit destination account
                to_account.balance += data['amount']
                to_account.save()

                Transaction.objects.create(
                    account=to_account,
                    transaction_type='CREDIT',
                    amount=data['amount'],
                    status='COMPLETED',
                    reference=reference,
                    description=data['description']
                )

                return Response({
                    "status": "success",
                    "reference": reference,
                    "amount": str(data['amount']),
                    "new_balance": str(from_account.balance)
                }, 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": "Transfer failed", "details": str(e)},
                status=status.HTTP_500_INTERNAL_SERVER_ERROR
            )