Refactoring http/main into http router

cmd/http/main.go

@@ -2,26 +2,16 @@ package http
 
 import (
 	"embed"
-	"encoding/json"
 	"flag"
 	"fmt"
 	"io/fs"
 	"log"
-	"maps"
 	"net/http"
 	"os"
-	"path"
-	"slices"
-	"sort"
-	"strconv"
-	"strings"
-	"time"
 
 	_ "embed"
 
-	"gogs.inhome.blapointe.com/ana-ledger/src/ana"
 	"gogs.inhome.blapointe.com/ana-ledger/src/ledger"
-	"gogs.inhome.blapointe.com/ana-ledger/src/view"
 )
 
 //go:embed public/*
@@ -38,16 +28,13 @@ var publicHandler = func() http.Handler {
 }()
 
 func Main() {
-	foo := flag.String("foo", "bal", "bal or reg")
 	likeName := flag.String("like-name", ".", "regexp to match")
 	likeBefore := flag.String("like-before", "9", "date str to compare")
 	likeAfter := flag.String("like-after", "0", "date str to compare")
-	likeLedger := flag.Bool("like-ledger", false, "limit data to these -like-* rather than zoom to these -like-*")
 	groupName := flag.String("group-name", ".*", "grouping to apply to names")
 	groupDate := flag.String("group-date", ".*", "grouping to apply to dates")
 	bpiPath := flag.String("bpi", "/dev/null", "bpi file")
-	jsonOutput := flag.Bool("json", false, "json output")
+	httpOutput := flag.String("http", ":8080", "http output listen address, like :8080")
-	httpOutput := flag.String("http", "", "http output listen address, like :8080")
 	flag.Parse()
 
 	if flag.NArg() < 1 {
@@ -59,352 +46,17 @@ func Main() {
 		panic(err)
 	}
 
-	bpis := make(ledger.BPIs)
+	r := NewRouter(
-	if *bpiPath != "" {
+		f,
-		bpis, err = ledger.NewBPIs(*bpiPath)
+		*likeName,
-		if err != nil {
+		*likeBefore,
-			panic(err)
+		*likeAfter,
-		}
+		*groupName,
-	}
+		*groupDate,
-
+		*bpiPath,
-	if *httpOutput != "" {
+	)
-		foo := func(w http.ResponseWriter, r *http.Request) {
+	log.Println("listening on", *httpOutput)
-			if !strings.HasPrefix(r.URL.Path, "/api") {
+	if err := http.ListenAndServe(*httpOutput, r); err != nil {
-				publicHandler.ServeHTTP(w, r)
+		panic(err)
-				return
-			}
-
-			reqF := f
-			if queryF := r.URL.Query().Get("f"); queryF != "" {
-				queryF = path.Join("http", queryF)
-				reqF, err = ledger.NewFiles(queryF)
-				if err != nil {
-					panic(err)
-				}
-			}
-
-			switch r.URL.Path {
-			case "/api/transactions":
-				lastNLines, err := reqF.TempGetLastNLines(20)
-				if err != nil {
-					panic(err)
-				}
-				deltas, err := reqF.Deltas()
-				if err != nil {
-					panic(err)
-				}
-				json.NewEncoder(w).Encode(map[string]any{
-					"deltas":     deltas.Like(ledger.LikeAfter(time.Now().Add(-1 * time.Hour * 24 * 365 / 2).Format("2006-01"))),
-					"balances":   deltas.Balances().Like("^AssetAccount:").WithBPIs(bpis),
-					"lastNLines": lastNLines,
-				})
-				return
-			case "/api/lastnlines":
-				if r.Method != http.MethodPut {
-					http.NotFound(w, r)
-					return
-				}
-				var lines []string
-				if err := json.NewDecoder(r.Body).Decode(&lines); err != nil {
-					panic(err)
-				}
-				if err := reqF.TempSetLastNLines(20, lines); err != nil {
-					http.Error(w, err.Error(), http.StatusBadRequest)
-				}
-				w.WriteHeader(http.StatusResetContent)
-				return
-			}
-
-			deltas, err := f.Deltas()
-			if err != nil {
-				panic(err)
-			}
-			deltas = deltas.Group(ledger.GroupName(*groupName), ledger.GroupDate(*groupDate))
-			like := ledger.Likes{
-				ledger.LikeName(*likeName),
-				ledger.LikeBefore(*likeBefore),
-				ledger.LikeAfter(*likeAfter),
-			}
-
-			foolike := make(ledger.Likes, 0)
-			for _, v := range r.URL.Query()["likeName"] {
-				foolike = append(foolike, ledger.LikeName(v))
-			}
-			for _, v := range r.URL.Query()["likeAfter"] {
-				foolike = append(foolike, ledger.LikeAfter(v))
-			}
-			for _, v := range r.URL.Query()["likeBefore"] {
-				foolike = append(foolike, ledger.LikeBefore(v))
-			}
-			if len(foolike) == 0 {
-				foolike = like
-			}
-			deltas = deltas.Like(foolike...)
-
-			// MODIFIERS
-			for i, whatIf := range r.URL.Query()["whatIf"] {
-				fields := strings.Fields(whatIf)
-				date := "2001-01"
-				name := fields[0]
-				currency := ledger.Currency(fields[1])
-				value, err := strconv.ParseFloat(fields[2], 64)
-				if err != nil {
-					panic(err)
-				}
-				deltas = append(deltas, ledger.Delta{
-					Date:        date,
-					Name:        name,
-					Value:       value,
-					Currency:    currency,
-					Description: fmt.Sprintf("?whatIf[%d]", i),
-				})
-			}
-
-			register := deltas.Register()
-			predicted := make(ledger.Register)
-			bpis := maps.Clone(bpis)
-
-			if predictionMonths, err := strconv.ParseInt(r.URL.Query().Get("predictionMonths"), 10, 16); err == nil && predictionMonths > 0 {
-				window := time.Hour * 24.0 * 365.0 / 12.0 * time.Duration(predictionMonths)
-				// TODO whatif
-				prediction := make(ana.Prediction, 0)
-				for _, spec := range r.URL.Query()["prediction"] {
-					idx := strings.Index(spec, "=")
-					k := spec[:idx]
-					fields := strings.Fields(spec[idx+1:])
-					switch k {
-					case "interest":
-						apy, err := strconv.ParseFloat(fields[2], 64)
-						if err != nil {
-							panic(err)
-						}
-						prediction = append(prediction, ana.NewInterestPredictor(fields[0], fields[1], apy))
-					case "autoContributions":
-						prediction = append(prediction, ana.NewAutoContributionPredictor(register))
-					case "contributions":
-						name := fields[0]
-						currency := ledger.Currency(fields[1])
-						value, err := strconv.ParseFloat(fields[2], 64)
-						if err != nil {
-							panic(err)
-						}
-						prediction = append(prediction, ana.NewContributionPredictor(ledger.Balances{name: ledger.Balance{currency: value}}))
-					default:
-						panic(k)
-					}
-				}
-				predicted = prediction.Predict(register, window)
-
-				for _, currencyRate := range r.URL.Query()["predictFixedGrowth"] {
-					currency := strings.Split(currencyRate, "=")[0]
-					rate, err := strconv.ParseFloat(strings.Split(currencyRate, "=")[1], 64)
-					if err != nil {
-						panic(err)
-					}
-					bpis, err = ana.BPIsWithFixedGrowthPrediction(bpis, window, currency, rate)
-					if err != nil {
-						panic(err)
-					}
-				}
-			}
-
-			if r.URL.Query().Get("bpi") == "true" {
-				register = register.WithBPIs(bpis)
-				predicted = predicted.WithBPIs(bpis)
-			}
-			if zoomStart, err := time.ParseInLocation("2006-01", r.URL.Query().Get("zoomStart"), time.Local); err == nil {
-				register = register.Between(zoomStart, time.Now().Add(time.Hour*24*365*100))
-				predicted = predicted.Between(zoomStart, time.Now().Add(time.Hour*24*365*100))
-			}
-			// /MODIFIERS
-
-			dates := register.Dates()
-			names := register.Names()
-			for _, date := range predicted.Dates() {
-				found := false
-				for i := range dates {
-					found = found || dates[i] == date
-				}
-				if !found {
-					dates = append(dates, date)
-				}
-			}
-			for _, name := range predicted.Names() {
-				found := false
-				for i := range names {
-					found = found || names[i] == name
-				}
-				if !found {
-					names = append(names, name)
-				}
-			}
-			instant := map[string]string{}
-			toChart := func(cumulative bool, display string, reg ledger.Register) view.Chart {
-				nameCurrencyDateValue := map[string]map[ledger.Currency]map[string]float64{}
-				for date, balances := range reg {
-					for name, balance := range balances {
-						for currency, value := range balance {
-							if _, ok := nameCurrencyDateValue[name]; !ok {
-								nameCurrencyDateValue[name] = make(map[ledger.Currency]map[string]float64)
-							}
-							if _, ok := nameCurrencyDateValue[name][currency]; !ok {
-								nameCurrencyDateValue[name][currency] = make(map[string]float64)
-							}
-							nameCurrencyDateValue[name][currency][date] += value
-						}
-					}
-				}
-
-				chart := view.NewChart("line")
-				if v := display; v != "" {
-					chart = view.NewChart(v)
-				}
-
-				chart.AddX(dates)
-
-				if cumulative {
-					for _, name := range names {
-						currencyDateValue := nameCurrencyDateValue[name]
-						for currency, dateValue := range currencyDateValue {
-							series := make([]int, len(dates))
-							for i := range dates {
-								var lastValue float64
-								for j := range dates[:i+1] {
-									if newLastValue, ok := dateValue[dates[j]]; ok {
-										lastValue = newLastValue
-									}
-								}
-								series[i] = int(lastValue)
-							}
-							key := fmt.Sprintf("%s (%s)", name, currency)
-							for i := range dates {
-								if !(reg.Dates()[0] <= dates[i] && dates[i] <= reg.Dates()[len(reg.Dates())-1]) {
-									series[i] = 0
-								} else {
-									instant[key] = fmt.Sprintf("@%s %v", dates[i], series[i])
-								}
-							}
-							if slices.Min(series) != 0 || slices.Max(series) != 0 {
-								chart.AddY(key, series)
-							}
-						}
-					}
-				} else {
-					for _, name := range names {
-						currencyDateValue := nameCurrencyDateValue[name]
-						for currency, dateValue := range currencyDateValue {
-							series := make([]int, len(dates))
-							for i := range dates {
-								var prevValue float64
-								var lastValue float64
-								for j := range dates[:i+1] {
-									if newLastValue, ok := dateValue[dates[j]]; ok {
-										prevValue = lastValue
-										lastValue = newLastValue
-									}
-								}
-								series[i] = int(lastValue - prevValue)
-							}
-							for i := range series { // TODO no prior so no delta
-								if series[i] != 0 {
-									series[i] = 0
-									break
-								}
-							}
-							key := fmt.Sprintf("%s (%s)", name, currency)
-							for i := range dates {
-								if !(reg.Dates()[0] <= dates[i] && dates[i] <= reg.Dates()[len(reg.Dates())-1]) {
-									series[i] = 0
-								} else {
-									instant[key] = fmt.Sprintf("@%s %v", dates[i], series[i])
-								}
-							}
-							if slices.Min(series) != 0 || slices.Max(series) != 0 {
-								chart.AddY(key, series)
-							}
-						}
-					}
-				}
-				return chart
-			}
-			primary := toChart(r.URL.Path == "/api/bal", r.URL.Query().Get("chart"), register)
-			if len(predicted) > 0 {
-				primary.Overlap(toChart(r.URL.Path == "/api/bal", "line", predicted))
-			}
-			if err := primary.Render(w); err != nil {
-				panic(err)
-			}
-			for k, v := range instant {
-				fmt.Fprintf(w, "<br>\n%s = %s", k, v)
-			}
-		}
-
-		log.Println("listening on", *httpOutput)
-		if err := http.ListenAndServe(*httpOutput, http.HandlerFunc(foo)); err != nil {
-			panic(err)
-		}
-	} else {
-		deltas, err := f.Deltas()
-		if err != nil {
-			panic(err)
-		}
-		deltas = deltas.Group(ledger.GroupName(*groupName), ledger.GroupDate(*groupDate))
-		like := ledger.Likes{ledger.LikeName(*likeName)}
-		if *likeLedger {
-			like = append(like, ledger.LikeBefore(*likeBefore))
-			like = append(like, ledger.LikeAfter(*likeAfter))
-			deltas = deltas.Like(like...)
-		} else {
-			deltas = deltas.Like(like...)
-			like = append(like, ledger.LikeBefore(*likeBefore))
-			like = append(like, ledger.LikeAfter(*likeAfter))
-		}
-
-		jsonResult := []any{}
-
-		switch *foo {
-		case "reg":
-			sort.Slice(deltas, func(i, j int) bool {
-				return deltas[i].Debug() < deltas[j].Debug()
-			})
-			register := deltas.Register()
-			for i := range deltas {
-				if like.All(deltas[i]) {
-					if !*jsonOutput {
-						fmt.Printf("%s (%+v)\n", deltas[i].Debug(), register[deltas[i].Date][deltas[i].Name].Debug())
-					} else {
-						jsonResult = append(jsonResult, map[string]any{
-							"name":    deltas[i].Name,
-							"delta":   deltas[i],
-							"balance": register[deltas[i].Date][deltas[i].Name],
-						})
-					}
-				}
-			}
-		case "bal":
-			deltas = deltas.Like(like...)
-			for k, v := range deltas.Balances() {
-				results := []string{}
-				for subk, subv := range v {
-					results = append(results, fmt.Sprintf("%s %.2f", subk, subv))
-				}
-				if len(results) > 0 {
-					if !*jsonOutput {
-						fmt.Printf("%s\t%s\n", k, strings.Join(results, " + "))
-					} else {
-						jsonResult = append(jsonResult, map[string]any{
-							"name":    k,
-							"balance": v,
-						})
-					}
-				}
-			}
-		default:
-			panic(fmt.Errorf("not impl %q", *foo))
-		}
-
-		if *jsonOutput {
-			json.NewEncoder(os.Stdout).Encode(jsonResult)
-		}
 	}
 }

cmd/http/public/transactions.html

@@ -17,11 +17,11 @@
       }
       function callback(responseBody, responseStatus) {
       }
-      var f = String(window.location).split("/transactions.html")[1]
+      //var f = String(window.location).split("/transactions.html")[1]
-      if (!f) {
+      //if (!f) {
-        f = "/ledger.dat"
+      //  f = "/ledger.dat"
-      }
+      //}
-      f = "." + f
+      //f = "." + f
       function init() {
         const zeroPad = (num, places) => String(num).padStart(places, '0')
         var d = new Date()
@@ -30,10 +30,10 @@
         var iframe = document.getElementsByTagName("iframe")[0]
         iframe.src = iframe.src.replace("YYYY-MM", replacement)
 
-        load(f)
+        load()
       }
-      function load(f) {
+      function load() {
-        http("GET", "/api/transactions?f="+f, (body, status) => {
+        http("GET", "/api/transactions" /*?f="+f*/, (body, status) => {
           var d = JSON.parse(body)
           loadBalances(d.balances)
           loadDeltas(d.deltas)
@@ -70,7 +70,7 @@
         document.getElementById("reg").innerHTML = result
       }
       function setLastNLines(form) {
-        http("PUT", "/api/lastnlines?f="+f, (body, status) => {
+        http("PUT", "/api/lastnlines" /*?f="+f*/, (body, status) => {
           if (status == 205) {
             init()
           }
@@ -79,7 +79,7 @@
       }
       function loadLastNLines(lastNLines) {
         var result = `<form onsubmit="setLastNLines(this); return false;" action="#">`
-        result += `  <div>${f}</div>`
+        //result += `  <div>${f}</div>`
         result += `  <textarea id="lastNLinesTextarea" name="lastNLines" style="height: 30em;">`
         for (var k in lastNLines) {
           result += lastNLines[k] + "\n"

cmd/http/router.go

@@ -0,0 +1,324 @@
+package http
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"path"
+	"slices"
+	"strconv"
+	"strings"
+	"time"
+
+	"gogs.inhome.blapointe.com/ana-ledger/src/ana"
+	"gogs.inhome.blapointe.com/ana-ledger/src/ledger"
+	"gogs.inhome.blapointe.com/ana-ledger/src/view"
+)
+
+type Router struct {
+	files ledger.Files
+	like  struct {
+		name   string
+		before string
+		after  string
+	}
+	group struct {
+		name string
+		date string
+	}
+	bpiPath string
+}
+
+func NewRouter(files ledger.Files, likeName, likeBefore, likeAfter string, groupName, groupDate string, bpiPath string) Router {
+	r := Router{}
+	r.files = files
+	r.like.name = likeName
+	r.like.before = likeBefore
+	r.like.after = likeAfter
+	r.group.name = groupName
+	r.group.date = groupDate
+	r.bpiPath = bpiPath
+	return r
+}
+
+func (router Router) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	bpis, err := router.bpis()
+	if err != nil {
+		panic(err)
+	}
+
+	if !strings.HasPrefix(r.URL.Path, "/api") {
+		publicHandler.ServeHTTP(w, r)
+		return
+	}
+
+	reqF := router.files
+	if queryF := r.URL.Query().Get("f"); queryF != "" {
+		queryF = path.Join("http", queryF)
+		reqF, err = ledger.NewFiles(queryF)
+		if err != nil {
+			panic(err)
+		}
+	}
+
+	switch r.URL.Path {
+	case "/api/transactions":
+		lastNLines, err := reqF.TempGetLastNLines(20)
+		if err != nil {
+			panic(err)
+		}
+		deltas, err := reqF.Deltas()
+		if err != nil {
+			panic(err)
+		}
+		json.NewEncoder(w).Encode(map[string]any{
+			"deltas":     deltas.Like(ledger.LikeAfter(time.Now().Add(-1 * time.Hour * 24 * 365 / 2).Format("2006-01"))),
+			"balances":   deltas.Balances().Like("^AssetAccount:").WithBPIs(bpis),
+			"lastNLines": lastNLines,
+		})
+		return
+	case "/api/lastnlines":
+		if r.Method != http.MethodPut {
+			http.NotFound(w, r)
+			return
+		}
+		var lines []string
+		if err := json.NewDecoder(r.Body).Decode(&lines); err != nil {
+			panic(err)
+		}
+		if err := reqF.TempSetLastNLines(20, lines); err != nil {
+			http.Error(w, err.Error(), http.StatusBadRequest)
+		}
+		w.WriteHeader(http.StatusResetContent)
+		return
+	}
+
+	deltas, err := reqF.Deltas()
+	if err != nil {
+		panic(err)
+	}
+	deltas = deltas.Group(ledger.GroupName(router.group.name), ledger.GroupDate(router.group.date))
+	like := ledger.Likes{
+		ledger.LikeName(router.like.name),
+		ledger.LikeBefore(router.like.before),
+		ledger.LikeAfter(router.like.after),
+	}
+
+	foolike := make(ledger.Likes, 0)
+	for _, v := range r.URL.Query()["likeName"] {
+		foolike = append(foolike, ledger.LikeName(v))
+	}
+	for _, v := range r.URL.Query()["likeAfter"] {
+		foolike = append(foolike, ledger.LikeAfter(v))
+	}
+	for _, v := range r.URL.Query()["likeBefore"] {
+		foolike = append(foolike, ledger.LikeBefore(v))
+	}
+	if len(foolike) == 0 {
+		foolike = like
+	}
+	deltas = deltas.Like(foolike...)
+
+	// MODIFIERS
+	for i, whatIf := range r.URL.Query()["whatIf"] {
+		fields := strings.Fields(whatIf)
+		date := "2001-01"
+		name := fields[0]
+		currency := ledger.Currency(fields[1])
+		value, err := strconv.ParseFloat(fields[2], 64)
+		if err != nil {
+			panic(err)
+		}
+		deltas = append(deltas, ledger.Delta{
+			Date:        date,
+			Name:        name,
+			Value:       value,
+			Currency:    currency,
+			Description: fmt.Sprintf("?whatIf[%d]", i),
+		})
+	}
+
+	register := deltas.Register()
+	predicted := make(ledger.Register)
+
+	if predictionMonths, err := strconv.ParseInt(r.URL.Query().Get("predictionMonths"), 10, 16); err == nil && predictionMonths > 0 {
+		window := time.Hour * 24.0 * 365.0 / 12.0 * time.Duration(predictionMonths)
+		// TODO whatif
+		prediction := make(ana.Prediction, 0)
+		for _, spec := range r.URL.Query()["prediction"] {
+			idx := strings.Index(spec, "=")
+			k := spec[:idx]
+			fields := strings.Fields(spec[idx+1:])
+			switch k {
+			case "interest":
+				apy, err := strconv.ParseFloat(fields[2], 64)
+				if err != nil {
+					panic(err)
+				}
+				prediction = append(prediction, ana.NewInterestPredictor(fields[0], fields[1], apy))
+			case "autoContributions":
+				prediction = append(prediction, ana.NewAutoContributionPredictor(register))
+			case "contributions":
+				name := fields[0]
+				currency := ledger.Currency(fields[1])
+				value, err := strconv.ParseFloat(fields[2], 64)
+				if err != nil {
+					panic(err)
+				}
+				prediction = append(prediction, ana.NewContributionPredictor(ledger.Balances{name: ledger.Balance{currency: value}}))
+			default:
+				panic(k)
+			}
+		}
+		predicted = prediction.Predict(register, window)
+
+		for _, currencyRate := range r.URL.Query()["predictFixedGrowth"] {
+			currency := strings.Split(currencyRate, "=")[0]
+			rate, err := strconv.ParseFloat(strings.Split(currencyRate, "=")[1], 64)
+			if err != nil {
+				panic(err)
+			}
+			bpis, err = ana.BPIsWithFixedGrowthPrediction(bpis, window, currency, rate)
+			if err != nil {
+				panic(err)
+			}
+		}
+	}
+
+	if r.URL.Query().Get("bpi") == "true" {
+		register = register.WithBPIs(bpis)
+		predicted = predicted.WithBPIs(bpis)
+	}
+	if zoomStart, err := time.ParseInLocation("2006-01", r.URL.Query().Get("zoomStart"), time.Local); err == nil {
+		register = register.Between(zoomStart, time.Now().Add(time.Hour*24*365*100))
+		predicted = predicted.Between(zoomStart, time.Now().Add(time.Hour*24*365*100))
+	}
+	// /MODIFIERS
+
+	dates := register.Dates()
+	names := register.Names()
+	for _, date := range predicted.Dates() {
+		found := false
+		for i := range dates {
+			found = found || dates[i] == date
+		}
+		if !found {
+			dates = append(dates, date)
+		}
+	}
+	for _, name := range predicted.Names() {
+		found := false
+		for i := range names {
+			found = found || names[i] == name
+		}
+		if !found {
+			names = append(names, name)
+		}
+	}
+	instant := map[string]string{}
+	toChart := func(cumulative bool, display string, reg ledger.Register) view.Chart {
+		nameCurrencyDateValue := map[string]map[ledger.Currency]map[string]float64{}
+		for date, balances := range reg {
+			for name, balance := range balances {
+				for currency, value := range balance {
+					if _, ok := nameCurrencyDateValue[name]; !ok {
+						nameCurrencyDateValue[name] = make(map[ledger.Currency]map[string]float64)
+					}
+					if _, ok := nameCurrencyDateValue[name][currency]; !ok {
+						nameCurrencyDateValue[name][currency] = make(map[string]float64)
+					}
+					nameCurrencyDateValue[name][currency][date] += value
+				}
+			}
+		}
+
+		chart := view.NewChart("line")
+		if v := display; v != "" {
+			chart = view.NewChart(v)
+		}
+
+		chart.AddX(dates)
+
+		if cumulative {
+			for _, name := range names {
+				currencyDateValue := nameCurrencyDateValue[name]
+				for currency, dateValue := range currencyDateValue {
+					series := make([]int, len(dates))
+					for i := range dates {
+						var lastValue float64
+						for j := range dates[:i+1] {
+							if newLastValue, ok := dateValue[dates[j]]; ok {
+								lastValue = newLastValue
+							}
+						}
+						series[i] = int(lastValue)
+					}
+					key := fmt.Sprintf("%s (%s)", name, currency)
+					for i := range dates {
+						if !(reg.Dates()[0] <= dates[i] && dates[i] <= reg.Dates()[len(reg.Dates())-1]) {
+							series[i] = 0
+						} else {
+							instant[key] = fmt.Sprintf("@%s %v", dates[i], series[i])
+						}
+					}
+					if slices.Min(series) != 0 || slices.Max(series) != 0 {
+						chart.AddY(key, series)
+					}
+				}
+			}
+		} else {
+			for _, name := range names {
+				currencyDateValue := nameCurrencyDateValue[name]
+				for currency, dateValue := range currencyDateValue {
+					series := make([]int, len(dates))
+					for i := range dates {
+						var prevValue float64
+						var lastValue float64
+						for j := range dates[:i+1] {
+							if newLastValue, ok := dateValue[dates[j]]; ok {
+								prevValue = lastValue
+								lastValue = newLastValue
+							}
+						}
+						series[i] = int(lastValue - prevValue)
+					}
+					for i := range series { // TODO no prior so no delta
+						if series[i] != 0 {
+							series[i] = 0
+							break
+						}
+					}
+					key := fmt.Sprintf("%s (%s)", name, currency)
+					for i := range dates {
+						if !(reg.Dates()[0] <= dates[i] && dates[i] <= reg.Dates()[len(reg.Dates())-1]) {
+							series[i] = 0
+						} else {
+							instant[key] = fmt.Sprintf("@%s %v", dates[i], series[i])
+						}
+					}
+					if slices.Min(series) != 0 || slices.Max(series) != 0 {
+						chart.AddY(key, series)
+					}
+				}
+			}
+		}
+		return chart
+	}
+	primary := toChart(r.URL.Path == "/api/bal", r.URL.Query().Get("chart"), register)
+	if len(predicted) > 0 {
+		primary.Overlap(toChart(r.URL.Path == "/api/bal", "line", predicted))
+	}
+	if err := primary.Render(w); err != nil {
+		panic(err)
+	}
+	for k, v := range instant {
+		fmt.Fprintf(w, "<br>\n%s = %s", k, v)
+	}
+}
+
+func (r Router) bpis() (ledger.BPIs, error) {
+	if r.bpiPath == "" {
+		return make(ledger.BPIs), nil
+	}
+	return ledger.NewBPIs(r.bpiPath)
+}