bel/ana-ledger
1
0
Fork 0
Code Actions Packages Projects Releases Activity

Compare commits

base: bel:ed0ce8355623926ca5f09c01e117fd6c8fccd3c5
Branches Tags
bel:main
..
compare: bel:4d01a5e48137f8b0c71088ddd87aac6700456815
Branches Tags
bel:main

2 Commits
ed0ce83556 ... 4d01a5e481

Author SHA1 Message Date
Bel LaPointe
4d01a5e481 impl normalize in HTTP
All checks were successful
cicd / ci (push) Successful in 2m18s
Details
2025-02-21 15:31:09 -07:00
Bel LaPointe
5cc7b7ec55 impl ana.Normalizer 2025-02-21 15:06:44 -07:00
4 changed files with 167 additions and 9 deletions
Expand all files Collapse all files

18
cmd/http/public/transactions.html
View File

@@ -47,9 +47,10 @@
} }
function load(callback) { function load(callback) {
http("GET", "/api/transactions" /*?f="+f*/, (body, status) => { http("GET", "/api/transactions", (body, status) => {
var d = JSON.parse(body) var d = JSON.parse(body)
console.log("loading", d) console.log("loading", d)
loadNormalized(d.normalized)
loadBalances(d.balances) loadBalances(d.balances)
loadTransactions(d.transactions) loadTransactions(d.transactions)
if (callback != null) { if (callback != null) {
@@ -58,6 +59,17 @@
}) })
} }
function loadNormalized(normalized) {
console.log("loading normalized", normalized)
var result = `<table>`
for (var k in normalized) {
result += `<tr style="display: flex; flex-direction: row; width: 100%; justify-content: space-between;"><td>${k}</td><td>${Math.floor(normalized[k]["$"])}</td></tr>`
}
result += `</table>`
document.getElementById("norm").innerHTML = result
}
function loadBalances(balances) { function loadBalances(balances) {
console.log("loading balances", balances) console.log("loading balances", balances)
var result = `<table>` var result = `<table>`
@@ -198,6 +210,10 @@
<body onload="init();" style=""> <body onload="init();" style="">
<h2>Moolah2</h2> <h2>Moolah2</h2>
<details open> <details open>
<summary>Normalized</summary>
<div id="norm">
</details>
<details>
<summary>Balance</summary> <summary>Balance</summary>
<div id="bal"> <div id="bal">
</div> </div>

59
cmd/http/router.go
View File

@@ -6,6 +6,7 @@ import (
"fmt" "fmt"
"io" "io"
"io/fs" "io/fs"
"math"
"net/http" "net/http"
"os" "os"
"slices" "slices"
@@ -99,17 +100,59 @@ func (router Router) APITransactions(w http.ResponseWriter, r *http.Request) {
)) ))
recent := time.Hour * 24 * 365 / 6 recent := time.Hour * 24 * 365 / 6
json.NewEncoder(w).Encode(map[string]any{ normalizer := ana.NewNormalizer().
"deltas": houseRelatedDeltas. With("^Zach:", "2023-10-05", 139). // to turtle
Like(ledger.LikeAfter(time.Now().Add(-1 * recent).Format("2006-01"))), With("^Zach:", "2021-12-30", 135). // at pluralsight
"balances": houseRelatedDeltas.Balances(). With("^Zach:", "2020-07-30", 120). // to pluralsight
With("^Zach:", "2019-07-16", 77). // at fedex
With("^Zach:", "2017-02-16", 49). // to fedex
With("^Bel:", "2023-12-05", 190). // to render
With("^Bel:", "2022-12-31", 154). // at q
With("^Bel:", "2022-06-30", 148). // at q
With("^Bel:", "2021-12-31", 122). // at q
With("^Bel:", "2020-12-31", 118). // at q
With("^Bel:", "2019-12-31", 111). // at q
With("^Bel:", "2018-12-31", 92). // at q
With("^Bel:", "2018-02-16", 86) // to q
{
deltas := houseRelatedDeltas.
Like(ledger.LikeAfter(time.Now().Add(-1 * recent).Format("2006-01")))
balances := houseRelatedDeltas.Balances().
Like(`^(Zach|Bel|House[^:]*:Debts:)`). Like(`^(Zach|Bel|House[^:]*:Debts:)`).
Group(`^[^:]*`). Group(`^[^:]*`).
WithBPIs(bpis), WithBPIs(bpis)
"transactions": houseRelatedDeltas.
transactions := houseRelatedDeltas.
Like(ledger.LikeAfter(time.Now().Add(-1 * recent).Format("2006-01"))). Like(ledger.LikeAfter(time.Now().Add(-1 * recent).Format("2006-01"))).
Transactions(), Transactions()
})
normalized := normalizer.Normalize(houseRelatedDeltas).Balances().
Like(`^(Zach|Bel):`).
Group(`^[^:]*:`).
WithBPIs(bpis)
var biggest float64
for _, v := range normalized {
if v := math.Abs(v["$"]); v > biggest {
biggest = v
}
}
for k, v := range normalized {
if v := math.Abs(v["$"]); v < biggest {
normalizedDelta := biggest - v
normalizedFactor := normalizer.NormalizeFactor(ledger.Delta{Name: k, Date: time.Now().Format("2006-01-02")})
normalized[fmt.Sprintf(`(%s trailing $)`, k)] = ledger.Balance{"$": normalizedDelta * normalizedFactor}
}
}
json.NewEncoder(w).Encode(map[string]any{
"deltas": deltas,
"balances": balances,
"normalized": normalized,
"transactions": transactions,
})
}
} }
func (router Router) APITrends(w http.ResponseWriter, r *http.Request) { func (router Router) APITrends(w http.ResponseWriter, r *http.Request) {

69
src/ana/normalize.go Normal file
View File

@@ -0,0 +1,69 @@
package ana
import (
"regexp"
"slices"
"strings"
"gogs.inhome.blapointe.com/ana-ledger/src/ledger"
)
type Normalizer struct {
m map[string][]normalize
}
type normalize struct {
startDate string
factor float64
}
func NewNormalizer() Normalizer {
return Normalizer{
m: make(map[string][]normalize),
}
}
func (n Normalizer) With(pattern, startDate string, factor float64) Normalizer {
n.m[pattern] = append(n.m[pattern], normalize{startDate: startDate, factor: factor})
slices.SortFunc(n.m[pattern], func(a, b normalize) int {
return -1 * strings.Compare(a.startDate, b.startDate)
})
return n
}
func (n Normalizer) Normalize(deltas ledger.Deltas) ledger.Deltas {
deltas = slices.Clone(deltas)
patterns := []string{}
for pattern := range n.m {
patterns = append(patterns, pattern)
}
like := ledger.LikeName(strings.Join(patterns, "|"))
for i, delta := range deltas {
if !like(delta) {
continue
}
deltas[i] = n.NormalizeDelta(delta)
}
return deltas
}
func (n Normalizer) NormalizeDelta(delta ledger.Delta) ledger.Delta {
delta.Value /= n.NormalizeFactor(delta)
return delta
}
func (n Normalizer) NormalizeFactor(delta ledger.Delta) float64 {
for pattern := range n.m {
if regexp.MustCompile(pattern).MatchString(delta.Name) {
for _, normalize := range n.m[pattern] {
if normalize.startDate < delta.Date {
return normalize.factor
}
}
}
}
return 1.0
}

30
src/ana/normalize_test.go Normal file
View File

@@ -0,0 +1,30 @@
package ana
import (
"testing"
"gogs.inhome.blapointe.com/ana-ledger/src/ledger"
)
func TestNormalize(t *testing.T) {
deltas := ledger.Deltas{
ledger.Delta{Date: "2024-12-04", Value: 100, Name: "Bel:Withdrawal"},
ledger.Delta{Date: "2024-12-06", Value: 100, Name: "Bel:Withdrawal"},
}
normalizer := NewNormalizer().
With("^Bel:", "2024-12-05", 190_000).
With("^Bel:", "2018-02-16", 86_000)
normalized := normalizer.Normalize(deltas)
for i, delta := range normalized {
t.Logf("[%d] %+v", i, delta)
}
if normalized[0].Value != 100/float64(86_000) {
t.Errorf("earliest transaction didnt use earliest salary")
}
if normalized[1].Value != 100/float64(190_000) {
t.Errorf("latest transaction didnt use latest salary")
}
}