Why, previous_due is not updated in CustomerAdd serializers | When one API is created then how to update another API in Django REST API?

Question

Here is my CustomerAdd models:

I need to populate the previous_due of these CustomerAdd models when CustomerBuySell models are created with customer_buy_sell_credit fields. What did I write wrong?

class CustomerAdd(models.Model):
    user = models.ForeignKey('accounts.CustomUser', on_delete=models.CASCADE)
    is_customer = models.BooleanField('customer status', default=True)
    is_supplier = models.BooleanField('supplier status', default=False)
    customer_name = models.CharField(max_length=100)
    customer_phone = models.CharField(max_length=15, unique=True, error_messages={'unique': "This customer_phone has "
                                                                                            "already been registered."})
    previous_due = models.DecimalField(max_digits=10, decimal_places=2, default=0.00)
    date = models.DateField(auto_now_add=True)
    picture = models.ImageField(upload_to='customer_add_pics', default='images.png')

    def __str__(self):
        return self.customer_name

    class Meta:
        verbose_name = "Customer Add"
        verbose_name_plural = "Customer Add"

    # @property
    # def total_due(self):
    #     qs = self.previous_due.objects.all().aggregate(previous_due=models.Sum('previous_due'))
    #     return qs['total_kcal']
    @property
    def get_previous_due(self):
        cbs_obj = CustomerBuySell()
        qs = self.previous_due = cbs_obj.customer_buy_sell_credit + int(self.previous_due)
        return qs

    def save(self, *args, **kwarg):
        self.previous_due = self.get_previous_due
        super(CustomerAdd, self).save(*args, **kwarg)

And, here is my CustomeBuySell model

class CustomerBuySell(models.Model):
    user = models.ForeignKey('accounts.CustomUser', on_delete=models.CASCADE, related_name='customer_buy_sell')
    customer = models.ForeignKey(CustomerAdd, on_delete=models.CASCADE, related_name='customer_buy_sell')
    customer_buy_sell_debit = models.DecimalField(max_digits=10, decimal_places=2, default=0.00)
    customer_buy_sell_credit = models.DecimalField(max_digits=10, decimal_places=2, default=0.00)
    description = models.CharField(max_length=250)
    date = models.DateField()
    sms = models.BooleanField(default=False)
    picture = models.ImageField(upload_to='customer_buy_sell_pics', default='images.png')

    def __str__(self):
        return self.customer.customer_name

    class Meta:
        verbose_name = "Customer BuySell"
        verbose_name_plural = "Customer BuySell"

Here are two serializers:

CustomerAddSerializer

class CustomerAddSerializer(serializers.ModelSerializer):
    # customer_buy_sell_debit = serializers.SerializerMethodField()
    # customer_buy_sell_credit = serializers.SerializerMethodField()
    def to_representation(self, instance):
        r = super(CustomerAddSerializer, self).to_representation(instance)
        cbs_obj = CustomerBuySell()
        c_add_obj = CustomerAdd()
        r.update({
            'previous_due': c_add_obj.previous_due + cbs_obj.customer_buy_sell_credit

        })
        return r

    class Meta:
        model = CustomerAdd
        fields = '__all__'

    # def get_customer_buy_sell_debit(self, data):
    #     print(data.id)
    #     previous_due = CustomerAdd.objects.filter(user=data.id).aggregate(total_previous_due=Sum('previous_due'))
    #     customer_buy_sell_debit = CustomerBuySell.objects.filter(customer=data.id).aggregate(
    #         total_customer_buy_sell_debit=Sum('customer_buy_sell_debit'))
    #     total_due = {**customer_buy_sell_debit, **previous_due}
    #     return Response({'customer_buy_sell_debit': total_due}).data

    def save(self, **kwargs):
        return super(CustomerAddSerializer, self).save(**kwargs)

    def create(self, validated_data):
        return super(CustomerAddSerializer, self).create(validated_data)

    def update(self, instance, validated_data):
        return super(CustomerAddSerializer, self).update(instance, validated_data)

    def validate(self, attrs):
        # customer_name = CustomerAdd.objects.filter(customer_name=attrs['customer_name'])
        # if customer_name.exists():
        #     raise ValidationError({"message": "customer name is already exist."})

        if attrs['customer_name']:
            for num in attrs['customer_name']:
                if num.isdigit():
                    raise serializers.ValidationError({'error': 'customer_name can not be numeric'})

        return super(CustomerAddSerializer, self).validate(attrs)

    def is_valid(self, raise_exception=False):
        return super(CustomerAddSerializer, self).is_valid(raise_exception)

    @property
    def data(self):
        return super(CustomerAddSerializer, self).data

    @property
    def validated_data(self):
        return super(CustomerAddSerializer, self).validated_data

And,

CustomerBuySellSerializer

class CustomerBuySellSerializer(serializers.ModelSerializer):
    # previous_due = serializers.StringRelatedField(source='CustomerAdd.previous_due')

    class Meta:
        model = CustomerBuySell
        fields = '__all__'

    def to_representation(self, instance):
        representation = super(CustomerBuySellSerializer, self).to_representation(instance)

        if instance.customer is not None:
            customer_name = instance.customer.customer_name
            representation['customer_name'] = customer_name
            return representation

    def save(self, **kwargs):
        return super(CustomerBuySellSerializer, self).save(**kwargs)

    def create(self, validated_data):
        return super(CustomerBuySellSerializer, self).create(validated_data)

    def update(self, instance, validated_data):
        return super(CustomerBuySellSerializer, self).update(instance, validated_data)


    def validate(self, attrs):
        return super(CustomerBuySellSerializer, self).validate(attrs)

    def is_valid(self, raise_exception=False):
        return super(CustomerBuySellSerializer, self).is_valid(raise_exception)

    @property
    def data(self):
        return super(CustomerBuySellSerializer, self).data

    @property
    def validated_data(self):
        return super(CustomerBuySellSerializer, self).validated_data

What previous_due is not updated in CustomerAdd models through API? Please help me!