Django: Implementing fund reversal in post_save signal

Question

I'm using django post_save signal to update the status of a transaction based on whether funds are received. The problem is that funds_received is not working as expected. The issue is in using .exists(), because, it checks if there is any account with the exact balance equal to the transaction amount. If anyone has suggestions or knows of a better way for checking if funds are received, I would greatly appreciate the guidance.

from django.db.models.signals import post_save
from django.dispatch import receiver
from .models import Transaction, Account

@receiver(post_save, sender=Transaction)
def transaction_status(sender, instance, created, **kwargs):
    if created:
        amount = instance.amount
        sender_account = instance.sender.account
        receiver_account_number = instance.account_number
        receiver_account = account.objects.get(account_number=receiver_account_number)

        check_if_funds_received = Account.objects.filter(account_balance=amount).exists()

        funds_received = check_if_funds_received

        if funds_received:
            instance.status = 'Success'
            instance.save()
        else:
            instance.status = 'Reversed'
            instance.save()
            # return funds to sender
            sender_account.account_balance += amount
            sender_account.save()

My Models:

class Account(models.Model):
    user = models.OneToOneField(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
    account_number = models.BigIntegerField(unique=True)
    account_balance = models.DecimalField(max_digits=12, decimal_places=6)
    account_id = models.CharField(max_length=15, unique=True)
    user_qrcode = models.ImageField()
    first_name = models.CharField(max_length=50)
    last_name = models.CharField(max_length=50)
    account_status = models.CharField(max_length=50, choices=ACCOUNT_STATUS)
    pin = models.CharField(max_length=4)
    
    def __str__(self):
        return str(self.user.first_name)


class Transaction(models.Model):
    STATUS = (
        ('Success', 'Success'),
        ('Reversed', 'Reversed')
    )
    sender = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name='sender')
    receiver = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name='receiver')
    amount = models.DecimalField(max_digits=12, decimal_places=6)
    account_number = models.BigIntegerField()
    first_name = models.CharField(max_length=50)
    last_name = models.CharField(max_length=50)
    status = models.CharField(max_length=50, choices=STATUS)
    reference = models.CharField(max_length=30, default=reference_number, unique=True)
    pin = models.CharField(max_length=4)

    views.py
from decimal import Decimal
from django.contrib import messages

def create_transfer(request):
    if request.method == 'POST':
        
        amount = Decimal(request.POST.get('amount'))
        first_name = request.POST.get('first_name')
        last_name = request.POST.get('last_name')
        pin = request.POST.get('pin')

        sender_account = Account.objects.get(user=request.user)  
        receiver_account = Account.objects.get(account_number=request.POST.get('account_number'))

        if sender_account.account_balance >= amount:
            sender_account.account_balance -= amount
            sender_account.save()

            receiver_account.account_balance += amount
            receiver_account.save()

            Transaction.objects.create(
                sender=sender_account.user, 
                receiver=receiver_account.user,
                amount=amount,
                pin=pin, 
                first_name=receiver_account.first_name, 
                last_name=receiver_account.last_name,
                account_number=receiver_account
            )
        else:
            messages.error(request, 'Insufficient Funds')
            return redirect('Transaction')
    return render(request, 'create_transfer.html')

Answer 1

IMO your solution to this issue is wrong in the first place.

In your case the transaction is considered successful, because account balance was updated. But it should be other way around.

Balance should be updated, because transaction was successful.

You can even implement balance as a property of a Account. It will be calculated on the fly based on the sum of successful Transactions to this account.

Your Transaction model fields receiver and sender should also point to Account instead of the User profile. It will be much simpler to link it to correct account. Account already has FK to User

Here is simplified case. I think it will be a good way to start from this

class Transaction(models.Model):
    amount = models.DecimalField(max_digits=10, decimal_places=2, null=False, blank=False)
    status = models.CharField(max_length=255)
    timestamp = models.DateTimeField(auto_now_add=True)
    receiver = models.ForeignKey(Account, related_name="received_transactions", on_delete=models.CASCADE)
    sender = models.ForeignKey(Account, related_name="sent_transactions", on_delete=models.CASCADE)

class Account(models.Model):
    @property
    def account_balance(self):
        debit_balance = self.received_transactions.filter(status=SUCCESS).aggregate(debit=Sum("amount", default=0))["debit"]
        credit_balance = self.sent_transactions.filter(status=SUCCESS).aggregate(credit=Sum("amount", default=0))["credit"]

        return debit_balance - credit_balance