How can I serialize the Transaction model in django rest framework

Question

There are two reasons why the Transaction model should have a sender and receiver and assign them to the CustomUser model with different related names. It could help answer questions like:

Who initiated the Transaction?

Who received the funds?

We want to serialize this model because our company intends to use React.js as the frontend of the application. I would like to know how to validate the serialization to ensure that the sender can send funds from their account to another.

As you can see this view, I created it based on django template:

def transfer(request):
    if request.method == 'POST':
        account_number = request.POST['account_number']
        amount = Decimal(request.POST['amount'])
        superuser_account = Account.objects.get(user='superuser username') # set this username to the admin username or your preferred account.
        sender_account = Account.objects.get(user=request.user)
        receiver_account = Account.objects.get(account_number=account_number)

        interest_rate = 0.02
        deduction = amount * interest_rate

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

            receiver_account.account_balance += amount
            receiver_account.save()
  
            superuser_account.account_balance += deduction
            superuser_account.save()
            
            Transaction.objects.create(
                sender=request.user, receiver=receiver_account.user,
                amount=amount, account_number=account_number
            )
            return redirect ('Transfer')
        else:
            messages.error(request, 'Insufficient Funds')
            return redirect ('Transfer')
    return render(request, 'transfer.html')

This view checks if the sender account balance is greater than or equal to the specified transfer amount. If the sender doesn't have enough funds, it sets an error message and redirects to a Transfer page. The code also check if there are sufficient funds, the code will send the specified amount from the sender account balance and adds the same amount to the receiver account balance, and then saves these changes to the database, but using django rest framework it only have something like this:

@api_view(['POST'])

def create_transaction(request):

    if request.method == 'POST':

        serializer = TransactionSerializer(data=request.data)

        if serializer.is_valid():

            serializer.save()

            return Response(serializer.data, status=status.HTTP_201_CREATED)

        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

In this context, we cannot permit the sender to transfer funds from their account to another account, and the receiver's account balance will not be updated. How can we validate this scenario to distinguish between the sender and receiver and update the receiver's account balance based on the amount from the Transaction model?

Answer 1

To achieve the functionality you described, where you want to ensure that the sender can send funds from their account to another, and that the receiver's account balance is updated accordingly, you should add custom validation to your Django REST framework view using a Serializer. In your case, you are using the TransactionSerializer to create transactions, and you can add custom validation logic within this serializer.

Here's how you can modify your TransactionSerializer to handle the validation and update the account balances:

from rest_framework import serializers
from .models import Transaction, Account

class TransactionSerializer(serializers.ModelSerializer):
    class Meta:
        model = Transaction
        fields = '__all__'

    def validate(self, data):
        sender = data.get('sender')
        receiver = data.get('receiver')
        amount = data.get('amount')

        # Ensure that the sender and receiver are different
        if sender == receiver:
            raise serializers.ValidationError("Sender and receiver cannot be the same.")

        sender_account = Account.objects.get(user=sender)
        receiver_account = Account.objects.get(user=receiver)

        # Check if the sender has sufficient funds
        if sender_account.account_balance < amount:
            raise serializers.ValidationError("Insufficient Funds.")

        # Update the account balances
        sender_account.account_balance -= amount
        receiver_account.account_balance += amount

        # Save the updated account balances to the database
        sender_account.save()
        receiver_account.save()

        return data

In the above code:

We override the validate method in the TransactionSerializer to add custom validation logic.

We ensure that the sender and receiver are different, as you mentioned.

We check if the sender has sufficient funds. If not, we raise a validation error.

If the sender has sufficient funds, we update the sender's and receiver's account balances accordingly and save them to the database.

With this custom validation in place, when you create a Transaction object through your Django REST framework view, the serializer will ensure that the sender can send funds to another account, and the receiver's account balance will be updated based on the amount specified in the transaction. If any validation checks fail, the serializer will raise a validation error, which will be returned in the response.

Make sure to update your view to use this serializer, and you should have the desired functionality in your REST API.