diff --git a/src/expenses/expenseDebts.go b/src/expenses/expenseDebts.go index eb57d00..f08e7f1 100644 --- a/src/expenses/expenseDebts.go +++ b/src/expenses/expenseDebts.go @@ -63,24 +63,73 @@ func filterExpenseParticipants(e *mod.Expense) (UserTabs, UserTabs) { return debtors, creditors } -func resolveDebts(debtors UserTabs, creditors UserTabs) []mod.Debt { - debts := []mod.Debt{} +// TODO +// 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? - // I should sketch this one first +func resolveDebt(creditor UserTab, debtors UserTabs) mod.Debts { + 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 } -func CalculateDebts(e *mod.Expense) ([]mod.Debt, error) { - // dc := NewDebtCalculator(e) - // dc.mapShares() - // dc.mapPayments() - // - // debts := dc.getDebts() +func resolveDebts(debtors UserTabs, creditors UserTabs) mod.Debts { + keyedDebts := make(map[CompoundKey]dec.Decimal) - debtors, creditors := filterExpenseParticipants(e) - _ = resolveDebts(debtors, creditors) + for _, creditor := range 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 } diff --git a/src/expenses/expenseDebts_aux_test.go b/src/expenses/expenseDebts_aux_test.go index 6f0b8e3..61cd962 100644 --- a/src/expenses/expenseDebts_aux_test.go +++ b/src/expenses/expenseDebts_aux_test.go @@ -67,6 +67,56 @@ var ( {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 expense3 = mod.Expense{ @@ -120,21 +170,21 @@ func TestSharesAndPaymentsMapping(t *testing.T) { } // func TestFilterExpenseParticipants(t *testing.T) { - // expectedDebtors := []Debt{ - // {user2, decimal.NewFromInt(43)}, - // {user4, decimal.NewFromInt(11)}, - // } - // slices.SortFunc(expectedDebtors, sortBySum) - // - // dc := NewDebtCalculator(&expense2) - // dc.mapShares() - // dc.mapPayments() - // - // debts := dc.getDebts() - // slices.SortFunc(debts, sortBySum) - // - // if !reflect.DeepEqual(expectedDebtors, debts) { - // t.Errorf("expected creditors and resulting creditors don't match:\n%+v\n%+v\n", - // expectedDebtors, debts) - // } +// expectedDebtors := []Debt{ +// {user2, decimal.NewFromInt(43)}, +// {user4, decimal.NewFromInt(11)}, +// } +// slices.SortFunc(expectedDebtors, sortBySum) +// +// dc := NewDebtCalculator(&expense2) +// dc.mapShares() +// dc.mapPayments() +// +// debts := dc.getDebts() +// slices.SortFunc(debts, sortBySum) +// +// if !reflect.DeepEqual(expectedDebtors, debts) { +// t.Errorf("expected creditors and resulting creditors don't match:\n%+v\n%+v\n", +// expectedDebtors, debts) +// } // } diff --git a/src/expenses/expenseDebts_test.go b/src/expenses/expenseDebts_test.go index 120871d..4ebcc9d 100644 --- a/src/expenses/expenseDebts_test.go +++ b/src/expenses/expenseDebts_test.go @@ -1,66 +1,11 @@ package expenses import ( - "testing" - + mod "expenses/expenses/models" 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) { // Use expense2 here for the test expectedCreditors := UserTabs{ @@ -86,78 +31,120 @@ func TestFilterExpenseParticipants(t *testing.T) { } } -// func TestCalculateDebtsTestCase1(t *testing.T) { -// expense := mod.Expense{ -// ExpID: 1, -// Description: "Test Exp", -// Value: decimal.NewFromFloat(150.0), -// Type: mod.Type{ -// TypeID: 1, -// TypeName: "Despesa", -// }, -// Category: mod.Category{ -// CategoryID: 0, -// CategoryName: "Groceries", -// }, -// Owner: mod.User{ -// UserID: 1, -// UserName: "ESilva", -// }, -// Date: 1753307982, -// Payments: []mod.ExpensePayment{ -// { -// ExpPaymID: 0, -// User: mod.User{ -// UserID: 1, -// UserName: "ESilva", -// }, -// PayedAmount: decimal.NewFromFloat(135.0), -// }, -// { -// ExpPaymID: 1, -// User: mod.User{ -// UserID: 2, -// UserName: "Kika", -// }, -// PayedAmount: decimal.NewFromFloat(15.0), -// }, -// }, -// Shares: []mod.ExpenseShare{ -// { -// ExpShareID: 0, -// User: mod.User{ -// UserID: 1, -// UserName: "ESilva", -// }, -// Share: decimal.NewFromFloat(0.5), -// }, -// { -// ExpShareID: 1, -// User: mod.User{ -// UserID: 2, -// UserName: "Kika", -// }, -// Share: decimal.NewFromFloat(0.5), -// }, -// }, -// } -// -// expectedDebts := []Debt{ -// { -// Debtor: mod.User{ -// UserID: 2, -// UserName: "Kika", -// }, -// Sum: decimal.NewFromInt(60), -// }, -// } -// slices.SortFunc(expectedDebts, sortBySum) -// -// resultDebts, err := calculateDebts() -// if err != nil { -// t.Fatalf("Debt calculation failed: %+v", err) -// } -// slices.SortFunc(resultDebts, sortBySum) -// -// assert.Equal(t, expectedDebts, resultDebts) -// } +func TestResolveDebt_ExactDebtsForCredit(t *testing.T) { + // Test1: + // Debt is solvable + debtors := UserTabs{ + {User: user1, Sum: dec.NewFromFloat(10.0)}, + {User: user2, Sum: dec.NewFromFloat(10.0)}, + {User: user3, Sum: dec.NewFromFloat(10.0)}, + } + creditor := UserTab{User: user4, Sum: dec.NewFromFloat(30.0)} + expectedDebts := mod.Debts{ + {Creditor: user4, Debtor: user1, Sum: dec.NewFromFloat(10.0)}, + {Creditor: user4, Debtor: user2, Sum: dec.NewFromFloat(10.0)}, + {Creditor: user4, Debtor: user3, Sum: dec.NewFromFloat(10.0)}, + } + expectedDebtors := UserTabs{ + {User: user1, Sum: dec.NewFromFloat(0.0)}, + {User: user2, Sum: dec.NewFromFloat(0.0)}, + {User: user3, Sum: dec.NewFromFloat(0.0)}, + } + + result := resolveDebt(creditor, debtors) + + if !result.Equal(expectedDebts) { + t.Errorf("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) + } +} + +func TestResolveDebt_LessDebtsThanCredit(t *testing.T) { + // Test2: + // Debt is not solvable: + debtors := UserTabs{ + {User: user1, Sum: dec.NewFromFloat(10.0)}, + {User: user2, Sum: dec.NewFromFloat(10.0)}, + } + creditor := UserTab{User: user4, Sum: dec.NewFromFloat(30.0)} + expectedDebts := mod.Debts{ + {Creditor: user4, Debtor: user1, Sum: dec.NewFromFloat(10.0)}, + {Creditor: user4, Debtor: user2, Sum: dec.NewFromFloat(10.0)}, + } + + result := resolveDebt(creditor, debtors) + + if !result.Equal(expectedDebts) { + t.Errorf("[Test2] Expected debts:\n%+v\nResult debts:\n%+v\n", + expectedDebts, result) + } +} + +func TestResolveDebt_EnoughDebtsForCredit(t *testing.T) { + debtors := UserTabs{ + {User: user1, Sum: dec.NewFromFloat(10.0)}, + {User: user2, Sum: dec.NewFromFloat(10.0)}, + {User: user3, Sum: dec.NewFromFloat(10.0)}, + } + creditor := UserTab{User: user4, Sum: dec.NewFromFloat(10.0)} + expectedDebts := mod.Debts{ + {Creditor: user4, Debtor: user1, Sum: dec.NewFromFloat(10.0)}, + } + + result := resolveDebt(creditor, debtors) + + if !result.Equal(expectedDebts) { + t.Errorf("[Test3] Expected debts:\n%+v\nResult debts:\n%+v\n", + expectedDebts, result) + } +} + +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) + } +} diff --git a/src/expenses/models/expenseDebts.go b/src/expenses/models/expenseDebts.go index d1a2b28..7f9f175 100644 --- a/src/expenses/models/expenseDebts.go +++ b/src/expenses/models/expenseDebts.go @@ -2,6 +2,7 @@ package models import ( "github.com/shopspring/decimal" + "sort" ) type Debt struct { @@ -9,6 +10,34 @@ type Debt struct { Debtor User 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() { }