Basic debt calculation, still have to some testing

Did this yesterday forgot to commit it
This commit is contained in:
2025-08-21 12:48:19 +01:00
parent a7cc916805
commit 7c3a203dd2
4 changed files with 277 additions and 162 deletions
+62 -13
View File
@@ -63,24 +63,73 @@ func filterExpenseParticipants(e *mod.Expense) (UserTabs, UserTabs) {
return debtors, creditors return debtors, creditors
} }
func resolveDebts(debtors UserTabs, creditors UserTabs) []mod.Debt { // TODO
debts := []mod.Debt{} // Instead of doing this impererively (I think?) create a struct that can
// handle doing the accounting while collecting the data instead
type CompoundKey struct {
Debtor mod.User
Creditor mod.User
}
// maybe create a map point to the debt of each user and count from there? func resolveDebt(creditor UserTab, debtors UserTabs) mod.Debts {
// I should sketch this one first debts := mod.Debts{}
credit := creditor.Sum
for k := range debtors {
if credit.IsZero() {
break
}
debt := mod.Debt{
Creditor: creditor.User,
Debtor: debtors[k].User,
Sum: dec.NewFromFloat(0.0),
}
if debtors[k].Sum.GreaterThanOrEqual(credit) {
debt.Sum = credit
} else {
debt.Sum = debtors[k].Sum
}
credit = credit.Sub(debt.Sum)
debtors[k].Sum = debtors[k].Sum.Sub(debt.Sum)
debts = append(debts, debt)
}
return debts return debts
} }
func CalculateDebts(e *mod.Expense) ([]mod.Debt, error) { func resolveDebts(debtors UserTabs, creditors UserTabs) mod.Debts {
// dc := NewDebtCalculator(e) keyedDebts := make(map[CompoundKey]dec.Decimal)
// dc.mapShares()
// dc.mapPayments()
//
// debts := dc.getDebts()
debtors, creditors := filterExpenseParticipants(e) for _, creditor := range creditors {
_ = resolveDebts(debtors, creditors) debt := resolveDebt(creditor, debtors)
return []mod.Debt{}, nil for _, d := range debt {
key := CompoundKey{Debtor: d.Debtor, Creditor: d.Creditor}
if _, ok := keyedDebts[key]; ok {
keyedDebts[key] = keyedDebts[key].Add(d.Sum)
} else {
keyedDebts[key] = d.Sum
}
}
}
debts := mod.Debts{}
for key, debt := range keyedDebts {
debt := mod.Debt{Debtor: key.Debtor, Creditor: key.Creditor, Sum: debt}
debts = append(debts, debt)
}
return debts
}
// TODO
// Are we sure there are no errors in here?
func CalculateDebts(e *mod.Expense) (mod.Debts, error) {
debtors, creditors := filterExpenseParticipants(e)
debts := resolveDebts(debtors, creditors)
return debts, nil
} }
+67 -17
View File
@@ -67,6 +67,56 @@ var (
{ExpPaymID: 7, User: user4, PayedAmount: decimal.NewFromInt(1)}, {ExpPaymID: 7, User: user4, PayedAmount: decimal.NewFromInt(1)},
}, },
} }
/*
Shares:
User1 0.3
User2 0.3
User3 0.3
User4 0.1
Payments | Debts
User1 80 | (0.3 * 160) - 80 = -32 (is owed 32)
User2 5 | (0.3 * 160) - 5 = 43 (owes 43)
User3 70 | (0.3 * 160) - 70 = -22 (is owed 22)
User4 5 | (0.1 * 160) - 5 = 11 (owes 11)
Debtors {u4, 11}, {u2, 43},
Creditors {u3, 22}, {u1, 32}
{u3, 22} - {u4, 11} = {u3, 11}, {u4, 00}
{u3, 11} - {u2, 43} = {u3, 00}, {u2, 32}
Debts:
{Debtor: u4, Creditor: u3, Sum: 11}
{Debtor: u2, Creditor: u3, Sum: 11}
Debtors {u4, 00}, {u2, 32}
Creditors {u3, 00}, {u1, 32}
{u1, 32} - {u2, 32} = {u1, 00} {u2, 00}
Debts:
{Debtor: u2, Creditor: u1, Sum: 32}
Final debts:
{Debtor: u4, Creditor: u3, Sum: 11}
{Debtor: u2, Creditor: u3, Sum: 11}
{Debtor: u2, Creditor: u1, Sum: 32}
1 2
Debtors: [U2: 43, U4: 11] -> [U2: 21, U4: 11] -> [U4: 11]
1 2
Creditors: [U3: -22, U1: -32] -> [U1: -32] -> [U1: -11]
Kill the debts with:
1. User3.Credit + User2.Debt -> -22 + 43 = 21 - can pay the 22
2. User1.Credit + User2.Debt -> -32 + 21 = -11 - can only pay 21
3. User1.Credit + User4.Debt -> -11 + 11 = 0 - can pay the 11
Summary:
{creditor: U3, debtor: U2, debt: 22} - U2 owes U3 22
{creditor: U1, debtor: U2, debt: 21} - U2 owes U1 21
{creditor: U1, debtor: U4, debt: 11} - U4 owes U1 11
*/
// Expense is: evenly shared and paid off // Expense is: evenly shared and paid off
expense3 = mod.Expense{ expense3 = mod.Expense{
@@ -120,21 +170,21 @@ func TestSharesAndPaymentsMapping(t *testing.T) {
} }
// func TestFilterExpenseParticipants(t *testing.T) { // func TestFilterExpenseParticipants(t *testing.T) {
// expectedDebtors := []Debt{ // expectedDebtors := []Debt{
// {user2, decimal.NewFromInt(43)}, // {user2, decimal.NewFromInt(43)},
// {user4, decimal.NewFromInt(11)}, // {user4, decimal.NewFromInt(11)},
// } // }
// slices.SortFunc(expectedDebtors, sortBySum) // slices.SortFunc(expectedDebtors, sortBySum)
// //
// dc := NewDebtCalculator(&expense2) // dc := NewDebtCalculator(&expense2)
// dc.mapShares() // dc.mapShares()
// dc.mapPayments() // dc.mapPayments()
// //
// debts := dc.getDebts() // debts := dc.getDebts()
// slices.SortFunc(debts, sortBySum) // slices.SortFunc(debts, sortBySum)
// //
// if !reflect.DeepEqual(expectedDebtors, debts) { // if !reflect.DeepEqual(expectedDebtors, debts) {
// t.Errorf("expected creditors and resulting creditors don't match:\n%+v\n%+v\n", // t.Errorf("expected creditors and resulting creditors don't match:\n%+v\n%+v\n",
// expectedDebtors, debts) // expectedDebtors, debts)
// } // }
// } // }
+119 -132
View File
@@ -1,66 +1,11 @@
package expenses package expenses
import ( import (
"testing" mod "expenses/expenses/models"
dec "github.com/shopspring/decimal" dec "github.com/shopspring/decimal"
"testing"
) )
/*
The debt calculation is pretty much the core functionality of this thing
Formula to calculate how much a given user owes:
(share * total) - payedAmount
TestCase1
A simple expense of 150 with:
Shares:
User1 0.5
User2 0.5
Payments | Debts
User1 135 | (0.5 * 150) - 135 = -60 (is owed 60)
User2 15 | (0.5 * 150) - 15 = 60 (owes 60)
Debtors: [User2: 60]
Credtiors: [User1: -60]
Kill the debts with:
User1.Debt + User2.Credit = 0 {creditor: User1, debtor: User2, debt: 60}
State Update:
Debtors: [User2: 0]
Credtiors: [User1: 0]
Summary:
User2 owes User1 60
TestCase2
An expense of 160 with:
Shares:
User1 0.3
User2 0.3
User3 0.3
User4 0.1
Payments | Debts
User1 80 | (0.5 * 160) - 80 = -32 (is owed 60)
User2 5 | (0.5 * 160) - 5 = 43 (owes 43)
User3 70 | (0.5 * 160) - 70 = -22 (is owed 22)
User4 5 | (0.5 * 160) - 5 = 11 (owes 11)
1 2
Debtors: [U2: 43, U4: 11] -> [U2: 21, U4: 11] -> [U4: 11]
1 2
Creditors: [U3: -22, U1: -32] -> [U1: -32] -> [U1: -11]
Kill the debts with:
1. User3.Credit + User2.Debt -> -22 + 43 = 21 - can pay the 22
2. User1.Credit + User2.Debt -> -32 + 21 = -11 - can only pay 21
3. User1.Credit + User4.Debt -> -11 + 11 = 0 - can pay the 11
Summary:
{creditor: U3, debtor: U2, debt: 22} - U2 owes U3 22
{creditor: U1, debtor: U2, debt: 21} - U2 owes U1 21
{creditor: U1, debtor: U4, debt: 11} - U4 owes U1 11
*/
func TestFilterExpenseParticipants(t *testing.T) { func TestFilterExpenseParticipants(t *testing.T) {
// Use expense2 here for the test // Use expense2 here for the test
expectedCreditors := UserTabs{ expectedCreditors := UserTabs{
@@ -86,78 +31,120 @@ func TestFilterExpenseParticipants(t *testing.T) {
} }
} }
// func TestCalculateDebtsTestCase1(t *testing.T) { func TestResolveDebt_ExactDebtsForCredit(t *testing.T) {
// expense := mod.Expense{ // Test1:
// ExpID: 1, // Debt is solvable
// Description: "Test Exp", debtors := UserTabs{
// Value: decimal.NewFromFloat(150.0), {User: user1, Sum: dec.NewFromFloat(10.0)},
// Type: mod.Type{ {User: user2, Sum: dec.NewFromFloat(10.0)},
// TypeID: 1, {User: user3, Sum: dec.NewFromFloat(10.0)},
// TypeName: "Despesa", }
// }, creditor := UserTab{User: user4, Sum: dec.NewFromFloat(30.0)}
// Category: mod.Category{ expectedDebts := mod.Debts{
// CategoryID: 0, {Creditor: user4, Debtor: user1, Sum: dec.NewFromFloat(10.0)},
// CategoryName: "Groceries", {Creditor: user4, Debtor: user2, Sum: dec.NewFromFloat(10.0)},
// }, {Creditor: user4, Debtor: user3, Sum: dec.NewFromFloat(10.0)},
// Owner: mod.User{ }
// UserID: 1, expectedDebtors := UserTabs{
// UserName: "ESilva", {User: user1, Sum: dec.NewFromFloat(0.0)},
// }, {User: user2, Sum: dec.NewFromFloat(0.0)},
// Date: 1753307982, {User: user3, Sum: dec.NewFromFloat(0.0)},
// Payments: []mod.ExpensePayment{ }
// {
// ExpPaymID: 0, result := resolveDebt(creditor, debtors)
// User: mod.User{
// UserID: 1, if !result.Equal(expectedDebts) {
// UserName: "ESilva", t.Errorf("Expected debts:\n%+v\nResult debts:\n%+v\n",
// }, expectedDebts, result)
// PayedAmount: decimal.NewFromFloat(135.0), }
// },
// { if !debtors.Equal(expectedDebtors) {
// ExpPaymID: 1, t.Errorf("Expected debtors:\n%+v\nResult debtors:\n%+v\n",
// User: mod.User{ expectedDebtors, debtors)
// UserID: 2, }
// UserName: "Kika", }
// },
// PayedAmount: decimal.NewFromFloat(15.0), func TestResolveDebt_LessDebtsThanCredit(t *testing.T) {
// }, // Test2:
// }, // Debt is not solvable:
// Shares: []mod.ExpenseShare{ debtors := UserTabs{
// { {User: user1, Sum: dec.NewFromFloat(10.0)},
// ExpShareID: 0, {User: user2, Sum: dec.NewFromFloat(10.0)},
// User: mod.User{ }
// UserID: 1, creditor := UserTab{User: user4, Sum: dec.NewFromFloat(30.0)}
// UserName: "ESilva", expectedDebts := mod.Debts{
// }, {Creditor: user4, Debtor: user1, Sum: dec.NewFromFloat(10.0)},
// Share: decimal.NewFromFloat(0.5), {Creditor: user4, Debtor: user2, Sum: dec.NewFromFloat(10.0)},
// }, }
// {
// ExpShareID: 1, result := resolveDebt(creditor, debtors)
// User: mod.User{
// UserID: 2, if !result.Equal(expectedDebts) {
// UserName: "Kika", t.Errorf("[Test2] Expected debts:\n%+v\nResult debts:\n%+v\n",
// }, expectedDebts, result)
// Share: decimal.NewFromFloat(0.5), }
// }, }
// },
// } func TestResolveDebt_EnoughDebtsForCredit(t *testing.T) {
// debtors := UserTabs{
// expectedDebts := []Debt{ {User: user1, Sum: dec.NewFromFloat(10.0)},
// { {User: user2, Sum: dec.NewFromFloat(10.0)},
// Debtor: mod.User{ {User: user3, Sum: dec.NewFromFloat(10.0)},
// UserID: 2, }
// UserName: "Kika", creditor := UserTab{User: user4, Sum: dec.NewFromFloat(10.0)}
// }, expectedDebts := mod.Debts{
// Sum: decimal.NewFromInt(60), {Creditor: user4, Debtor: user1, Sum: dec.NewFromFloat(10.0)},
// }, }
// }
// slices.SortFunc(expectedDebts, sortBySum) result := resolveDebt(creditor, debtors)
//
// resultDebts, err := calculateDebts() if !result.Equal(expectedDebts) {
// if err != nil { t.Errorf("[Test3] Expected debts:\n%+v\nResult debts:\n%+v\n",
// t.Fatalf("Debt calculation failed: %+v", err) expectedDebts, result)
// } }
// slices.SortFunc(resultDebts, sortBySum) }
//
// assert.Equal(t, expectedDebts, resultDebts) func TestResolveDebt_RenameMe(t *testing.T) {
// } debtors := UserTabs{
{User: user1, Sum: dec.NewFromFloat(10.0)},
}
expectedDebtors := UserTabs{
{User: user1, Sum: dec.NewFromFloat(3.0)},
}
creditor := UserTab{User: user4, Sum: dec.NewFromFloat(7.0)}
expectedDebts := mod.Debts{
{Creditor: user4, Debtor: user1, Sum: dec.NewFromFloat(7.0)},
}
result := resolveDebt(creditor, debtors)
if !result.Equal(expectedDebts) {
t.Errorf("[Test3] Expected debts:\n%+v\nResult debts:\n%+v\n",
expectedDebts, result)
}
if !debtors.Equal(expectedDebtors) {
t.Errorf("Expected debtors:\n%+v\nResult debtors:\n%+v\n",
expectedDebtors, debtors)
}
}
// TODO
// Create more test cases for this thing, make sure it really works
func TestResolveDebts(t *testing.T) {
expectedDebts := mod.Debts{
{Creditor: user3, Debtor: user4, Sum: dec.NewFromFloat(11.0)},
{Creditor: user3, Debtor: user2, Sum: dec.NewFromFloat(11.0)},
{Creditor: user1, Debtor: user2, Sum: dec.NewFromFloat(32.0)},
}
expectedDebts.SortBySum()
debtors, creditors := filterExpenseParticipants(&expense2)
debts := resolveDebts(debtors, creditors)
debts.SortBySum()
if !expectedDebts.Equal(debts) {
t.Errorf("Expected debts:\n%+v\nResult debts:\n%+v\n", expectedDebts, debts)
}
}
+29
View File
@@ -2,6 +2,7 @@ package models
import ( import (
"github.com/shopspring/decimal" "github.com/shopspring/decimal"
"sort"
) )
type Debt struct { type Debt struct {
@@ -9,6 +10,34 @@ type Debt struct {
Debtor User Debtor User
Sum decimal.Decimal Sum decimal.Decimal
} }
type Debts []Debt
func (ds Debts) SortBySum() {
sort.SliceStable(ds, func(i, j int) bool {
if cmp := ds[i].Sum.Cmp(ds[j].Sum); cmp != 0 {
return cmp > 0
}
if ds[i].Creditor.UserID != ds[j].Creditor.UserID {
return ds[i].Creditor.UserID < ds[j].Creditor.UserID
}
return ds[i].Debtor.UserID < ds[j].Debtor.UserID
})
}
func (ds Debts) Equal(t Debts) bool {
if len(ds) != len(t) {
return false
}
for k := range ds {
if ds[k].Creditor != t[k].Creditor || ds[k].Debtor != t[k].Debtor ||
!ds[k].Sum.Equal(t[k].Sum) {
return false
}
}
return true
}
func (d *Debt) Insert() { func (d *Debt) Insert() {
} }