` of `Output`, "Run again" link.
+- Replace stub **[go/internal/web/templates/flush_cache.tmpl](go/internal/web/templates/flush_cache.tmpl)** with: form (`POST /flush-cache` → ``), success banner when `Flushed`.
+
+### Modified files
+
+- **[go/go.mod](go/go.mod)** / `go.sum` — add `github.com/skip2/go-qrcode`.
+- **[go/internal/web/server.go](go/internal/web/server.go)** — register `GET /qr`, `GET /sync-bank` (replace stub), `GET /flush-cache` (form), `POST /flush-cache` (action), `GET /version`. Widen `Run(...)` signature to accept `fio.Client`, `sheets.Client`, and a `cache.Flusher` — these flow into a new `Deps` struct on `HTMLHandler`.
+- **[go/internal/web/html_handler.go](go/internal/web/html_handler.go)** — add `ServeQR`, real `ServeSync`, split `ServeFlushCacheGET` / `ServeFlushCachePOST`, add `ServeVersion` (delegates to api package).
+- **[go/internal/web/render.go](go/internal/web/render.go)** — add `SyncPageData{ PageData; Output string; Success bool }` and `FlushPageData{ PageData; Flushed bool; Deleted int }` view-models. (`pageNames` already includes `"sync"` and `"flush_cache"`; no change.)
+- **[go/internal/web/qr.go](go/internal/web/qr.go)** *(new file)* — pure helper: `BuildSPD(account, amount, message string, defaultAccount string) (payload string)` + `RenderQRCode(payload string) ([]byte, error)`. Easier to unit-test than a method on the handler.
+- **[go/internal/services/membership/loader.go](go/internal/services/membership/loader.go)** — add a small `CacheFlusher` interface (`Flush() (int, error)`); have `Sources` aggregate include it. *Alternative considered*: pass `*cache.FileCache` straight into `web.Run`. Choose whichever needs fewer test-stub edits — likely the direct-pass approach, since stubs in tests don't need cache behavior. **Decision: pass `cache.Flusher` directly into `web.Run` as a separate dependency, not through `Sources`.** Simpler, fewer interface changes.
+- **[go/internal/services/banksync/sync.go](go/internal/services/banksync/sync.go)** + `infer.go` — accept an optional `io.Writer` (in `SyncOpts.Logger` / `InferOpts.Logger`) and route progress prints through it; default to `os.Stdout` when nil for CLI parity.
+- **[go/cmd/fuj/main.go](go/cmd/fuj/main.go)** — in the `server` subcommand, build `fio.Client`, `sheets.Client`, and `cache.Flusher` (already constructed inside `membership.NewSources` — expose it or construct a sibling) and pass them into `web.Run`.
+
+## Reuse (already in the codebase)
+
+- **Bank sync**: `banksync.SyncToSheets` ([go/internal/services/banksync/sync.go](go/internal/services/banksync/sync.go)) and `banksync.InferPayments` ([go/internal/services/banksync/infer.go](go/internal/services/banksync/infer.go)) — same calls the CLI `sync` / `infer` subcommands use ([go/cmd/fuj/main.go:184](go/cmd/fuj/main.go#L184), [:222](go/cmd/fuj/main.go#L222)).
+- **Cache flush**: `(*cache.FileCache).Flush() (int, error)` ([go/internal/io/cache/filecache.go:92](go/internal/io/cache/filecache.go#L92)) — already returns the deleted count.
+- **Build metadata**: `BuildInfo{Version, Commit, BuildDate}` ([go/internal/web/server.go:28-35](go/internal/web/server.go#L28-L35)) is already plumbed everywhere; `/api/version` JSON shape is already correct ([go/internal/web/api/version.go](go/internal/web/api/version.go)).
+- **Template render pattern**: `Renderer.Render(w, name, data)` ([go/internal/web/render.go:98-108](go/internal/web/render.go#L98-L108)).
+- **Test scaffolding**: `web.NewRenderer()` + `httptest.NewRequest/NewRecorder` ([go/internal/web/html_handler_test.go:52-94](go/internal/web/html_handler_test.go#L52-L94)).
+
+## Tests
+
+Add to `go/internal/web/html_handler_test.go` (and one new `qr_test.go` for the SPD builder):
+
+- **`TestQRBuildSPD`** *(unit, in [go/internal/web/qr_test.go](go/internal/web/qr_test.go))* — table-driven: invalid account → fallback; `/`-account → `{num}*BC:{bc}`; IBAN → raw; amount `-1` → `0.00`; amount `99999999` → `9999999.00`; amount `"abc"` → `0.00`; message with `*` stripped; message length-clamped to 60.
+- **`TestServeQR`** — request `/qr?account=…&amount=10&message=Hi`; assert 200, `Content-Type: image/png`, body starts with PNG magic `\x89PNG\r\n\x1a\n`.
+- **`TestServeFlushCacheGet`** — assert form rendered, no banner.
+- **`TestServeFlushCachePost`** — fixture flusher returns 3; assert banner says "3" and `Flushed`.
+- **`TestServeSync`** — fixture banksync stubs return `(2, nil)` and `(1, nil)`, fixture flusher returns 4; assert page renders, status is success, output contains the section headers.
+- **`TestServeVersion`** — assert `application/json`, body `{"tag":"v0","commit":"abc1234","build_date":"2026-01-01"}`.
+- Extend the `TestHTMLHandlerSmoke` table to cover `/qr` and `/version`.
+
+## Verification (end-to-end)
+
+1. `cd go && go build ./... && go test ./...`
+2. `cd go && go run ./cmd/fuj server` — open http://localhost:8080
+3. Smoke:
+ - **/adults** → click `Pay` next to any unpaid month → modal shows QR image (this exercises `/qr`). Confirm a Czech banking app can scan it (visual check).
+ - Direct `/qr?account=2702008874/2010&amount=700&message=Test` → PNG renders.
+ - **/sync-bank** → click `[Sync Bank Data]` in nav → page shows "Syncing…", then sections + "Inferred Payments", "Cache Flushed", green status banner.
+ - **/flush-cache** → click `[Flush Cache]` → success banner with file count.
+ - **/version** in browser → JSON visible.
+ - Adults / juniors / payments still render (no regressions from `Run` signature change).
+4. Run the parity diff: `go run ./cmd/parity` — `/api/version` must still match Python.
+5. Append a CHANGELOG entry per `CLAUDE.md`; tick `M6.6` in [docs/plans/2026-05-03-2349-go-backend-rewrite-progress.md:118](docs/plans/2026-05-03-2349-go-backend-rewrite-progress.md#L118).
+
+## Branch / MR
+
+Per `CLAUDE.md` workflow: `feat/go-m6-6-action-pages` off `main`, push with `-u`, open with `tea pr create --base main --head feat/go-m6-6-action-pages`.
+
+## Out of scope (deferred)
+
+- Auth / CSRF protection on `/sync-bank` and `/flush-cache` — Python has none either; deferred to M8 hardening.
+- M6.7 (single-binary embed verification) — separate ticket.
+- Streaming progress for `/sync-bank` (currently buffered until completion, like Python).
+- Configurable QR error-correction level / size.
diff --git a/go/cmd/fuj/main.go b/go/cmd/fuj/main.go
index 78cb40e..21d6bda 100644
--- a/go/cmd/fuj/main.go
+++ b/go/cmd/fuj/main.go
@@ -11,6 +11,7 @@ import (
"fuj-management/go/internal/services/banksync"
"fuj-management/go/internal/services/membership"
"fuj-management/go/internal/web"
+ "io"
"log/slog"
"os"
"time"
@@ -82,9 +83,40 @@ func serverCmd(args []string) {
os.Exit(1)
}
+ sheetsCli, err := sheets.New(ctx, cfg.CredentialsPath, cfg.DriveTimeout)
+ if err != nil {
+ fmt.Fprintf(os.Stderr, "fuj server: sheets client for sync: %v\n", err)
+ os.Exit(1)
+ }
+ fioCli := fio.New(cfg.FioAPIToken, config.IBANAccountNum(cfg.BankAccount), nil)
+
+ actions := web.ActionHandlers{
+ BankSync: func(ctx context.Context, out io.Writer) error {
+ yr := time.Now().Year()
+ from := time.Date(yr, 1, 1, 0, 0, 0, 0, time.UTC)
+ to := time.Date(yr, 12, 31, 23, 59, 59, 0, time.UTC)
+
+ fmt.Fprintln(out, "=== Sync Fio Transactions ===")
+ n, err := banksync.SyncToSheets(ctx, config.PaymentsSheetID, fioCli, sheetsCli,
+ banksync.SyncOpts{From: from, To: to, Sort: true})
+ if err != nil {
+ return fmt.Errorf("sync: %w", err)
+ }
+ fmt.Fprintf(out, "Synced %d new transaction(s).\n\n", n)
+
+ fmt.Fprintln(out, "=== Infer Payments ===")
+ n, err = banksync.InferPayments(ctx, config.PaymentsSheetID, sheetsCli, sources, banksync.InferOpts{})
+ if err != nil {
+ return fmt.Errorf("infer: %w", err)
+ }
+ fmt.Fprintf(out, "Inferred %d row(s).\n", n)
+ return nil
+ },
+ }
+
build := web.BuildInfo{Version: version, Commit: commit, BuildDate: buildDate}
- if err := web.Run(logger, cfg.ServerAddr, build, sources, cfg); err != nil {
+ if err := web.Run(logger, cfg.ServerAddr, build, sources, cfg, actions); err != nil {
fmt.Fprintln(os.Stderr, err)
os.Exit(1)
}
diff --git a/go/go.mod b/go/go.mod
index 73f0f76..1ddba6f 100644
--- a/go/go.mod
+++ b/go/go.mod
@@ -5,6 +5,7 @@ go 1.26.1
require (
github.com/google/go-cmp v0.7.0
github.com/invopop/jsonschema v0.14.0
+ github.com/skip2/go-qrcode v0.0.0-20200617195104-da1b6568686e
golang.org/x/net v0.53.0
golang.org/x/text v0.36.0
google.golang.org/api v0.278.0
diff --git a/go/go.sum b/go/go.sum
index b975380..f389496 100644
--- a/go/go.sum
+++ b/go/go.sum
@@ -37,6 +37,8 @@ github.com/pb33f/ordered-map/v2 v2.3.1 h1:5319HDO0aw4DA4gzi+zv4FXU9UlSs3xGZ40wcP
github.com/pb33f/ordered-map/v2 v2.3.1/go.mod h1:qxFQgd0PkVUtOMCkTapqotNgzRhMPL7VvaHKbd1HnmQ=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/skip2/go-qrcode v0.0.0-20200617195104-da1b6568686e h1:MRM5ITcdelLK2j1vwZ3Je0FKVCfqOLp5zO6trqMLYs0=
+github.com/skip2/go-qrcode v0.0.0-20200617195104-da1b6568686e/go.mod h1:XV66xRDqSt+GTGFMVlhk3ULuV0y9ZmzeVGR4mloJI3M=
github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64=
diff --git a/go/internal/services/membership/loader.go b/go/internal/services/membership/loader.go
index ac8f326..25abf18 100644
--- a/go/internal/services/membership/loader.go
+++ b/go/internal/services/membership/loader.go
@@ -25,11 +25,17 @@ type ExceptionLoader interface {
LoadExceptions(ctx context.Context) (map[reconcile.ExceptionKey]reconcile.Exception, error)
}
+// CacheFlusher can invalidate all cached data.
+type CacheFlusher interface {
+ FlushCache() (int, error)
+}
+
// Sources is the aggregate interface required by ReconcileReport.
type Sources interface {
AttendanceLoader
TransactionLoader
ExceptionLoader
+ CacheFlusher
}
// NewStubSources returns a Sources whose every method returns ErrIOPending.
@@ -52,3 +58,5 @@ func (stubSources) LoadTransactions(_ context.Context) ([]reconcile.Transaction,
func (stubSources) LoadExceptions(_ context.Context) (map[reconcile.ExceptionKey]reconcile.Exception, error) {
return nil, ErrIOPending
}
+
+func (stubSources) FlushCache() (int, error) { return 0, nil }
diff --git a/go/internal/services/membership/reconcile_test.go b/go/internal/services/membership/reconcile_test.go
index 652033c..b74e8a0 100644
--- a/go/internal/services/membership/reconcile_test.go
+++ b/go/internal/services/membership/reconcile_test.go
@@ -31,6 +31,8 @@ func (f fakeSources) LoadExceptions(_ context.Context) (map[reconcile.ExceptionK
return f.exceptions, nil
}
+func (fakeSources) FlushCache() (int, error) { return 0, nil }
+
func TestReconcileReport(t *testing.T) {
t.Parallel()
s := fakeSources{
diff --git a/go/internal/services/membership/sources.go b/go/internal/services/membership/sources.go
index ca2eebe..ed006a8 100644
--- a/go/internal/services/membership/sources.go
+++ b/go/internal/services/membership/sources.go
@@ -111,6 +111,9 @@ func (s *realSources) LoadTransactions(ctx context.Context) ([]reconcile.Transac
return parseTransactionRows(rows)
}
+// FlushCache deletes all cached data files and resets in-memory cache state.
+func (s *realSources) FlushCache() (int, error) { return s.cache.Flush() }
+
// LoadExceptions fetches the exceptions tab (cached).
func (s *realSources) LoadExceptions(ctx context.Context) (map[reconcile.ExceptionKey]reconcile.Exception, error) {
rows, err := cache.Get(ctx, s.cache, "exceptions_dict",
diff --git a/go/internal/web/api/handler.go b/go/internal/web/api/handler.go
index 4a3b880..234a84c 100644
--- a/go/internal/web/api/handler.go
+++ b/go/internal/web/api/handler.go
@@ -23,6 +23,9 @@ type Handler struct {
Logger *slog.Logger
}
+// FlushCache invalidates all cached data via the underlying Sources.
+func (h *Handler) FlushCache() (int, error) { return h.Sources.FlushCache() }
+
// ServeVersion handles GET /api/version.
func (h *Handler) ServeVersion(w http.ResponseWriter, r *http.Request) {
writeJSON(w, VersionResponse{
diff --git a/go/internal/web/html_handler.go b/go/internal/web/html_handler.go
index adacb81..d252105 100644
--- a/go/internal/web/html_handler.go
+++ b/go/internal/web/html_handler.go
@@ -1,8 +1,11 @@
package web
import (
+ "bytes"
+ "fmt"
"fuj-management/go/internal/web/api"
"net/http"
+ "runtime/debug"
)
// HTMLHandler serves the Go-native HTML frontend.
@@ -10,11 +13,12 @@ type HTMLHandler struct {
renderer *Renderer
build BuildInfo
apiHandler *api.Handler
+ actions ActionHandlers
}
// NewHTMLHandler constructs an HTMLHandler.
-func NewHTMLHandler(r *Renderer, b BuildInfo, ah *api.Handler) *HTMLHandler {
- return &HTMLHandler{renderer: r, build: b, apiHandler: ah}
+func NewHTMLHandler(r *Renderer, b BuildInfo, ah *api.Handler, actions ActionHandlers) *HTMLHandler {
+ return &HTMLHandler{renderer: r, build: b, apiHandler: ah, actions: actions}
}
func (h *HTMLHandler) ServeAdults(w http.ResponseWriter, r *http.Request) {
@@ -62,10 +66,78 @@ func (h *HTMLHandler) ServePayments(w http.ResponseWriter, r *http.Request) {
})
}
+// ServeSync handles GET /sync-bank: runs sync+infer+flush then renders the result.
func (h *HTMLHandler) ServeSync(w http.ResponseWriter, r *http.Request) {
- h.renderer.Render(w, "sync", PageData{Active: "sync", Build: h.build})
+ pd := PageData{Active: "sync", Build: h.build}
+
+ if h.actions.BankSync == nil {
+ h.renderer.Render(w, "sync", SyncPageData{
+ PageData: pd,
+ Output: "Bank sync is not configured.",
+ Success: false,
+ })
+ return
+ }
+
+ var buf bytes.Buffer
+ success := true
+ if err := h.actions.BankSync(r.Context(), &buf); err != nil {
+ fmt.Fprintf(&buf, "\nError: %s\n\nStack trace:\n%s", err.Error(), debug.Stack())
+ success = false
+ }
+
+ fmt.Fprintln(&buf, "\n=== Flush Cache ===")
+ n, err := h.apiHandler.FlushCache()
+ if err != nil {
+ fmt.Fprintf(&buf, "flush error: %s\n", err.Error())
+ success = false
+ } else {
+ fmt.Fprintf(&buf, "%d cache file(s) deleted.\n", n)
+ }
+
+ h.renderer.Render(w, "sync", SyncPageData{
+ PageData: pd,
+ Output: buf.String(),
+ Success: success,
+ })
}
-func (h *HTMLHandler) ServeFlushCache(w http.ResponseWriter, r *http.Request) {
- h.renderer.Render(w, "flush_cache", PageData{Active: "flush", Build: h.build})
+// ServeFlushCacheGET handles GET /flush-cache: renders the confirmation form.
+func (h *HTMLHandler) ServeFlushCacheGET(w http.ResponseWriter, r *http.Request) {
+ h.renderer.Render(w, "flush_cache", FlushPageData{
+ PageData: PageData{Active: "flush", Build: h.build},
+ })
+}
+
+// ServeFlushCachePOST handles POST /flush-cache: flushes and re-renders with count.
+func (h *HTMLHandler) ServeFlushCachePOST(w http.ResponseWriter, r *http.Request) {
+ n, _ := h.apiHandler.FlushCache()
+ h.renderer.Render(w, "flush_cache", FlushPageData{
+ PageData: PageData{Active: "flush", Build: h.build},
+ Flushed: true,
+ Deleted: n,
+ })
+}
+
+// ServeQR handles GET /qr: generates and returns a Czech QR Platba PNG.
+func (h *HTMLHandler) ServeQR(w http.ResponseWriter, r *http.Request) {
+ q := r.URL.Query()
+ account := q.Get("account")
+ amount := q.Get("amount")
+ message := q.Get("message")
+ if account == "" {
+ account = h.apiHandler.Config.BankAccount
+ }
+ if amount == "" {
+ amount = "0"
+ }
+
+ payload := BuildSPD(account, amount, message, h.apiHandler.Config.BankAccount)
+ png, err := RenderQRCode(payload)
+ if err != nil {
+ http.Error(w, "qr encode: "+err.Error(), http.StatusInternalServerError)
+ return
+ }
+ w.Header().Set("Content-Type", "image/png")
+ _, _ = w.Write(png)
}
diff --git a/go/internal/web/html_handler_test.go b/go/internal/web/html_handler_test.go
index c079b52..8366afe 100644
--- a/go/internal/web/html_handler_test.go
+++ b/go/internal/web/html_handler_test.go
@@ -1,12 +1,15 @@
package web_test
import (
+ "bytes"
"context"
+ "encoding/json"
"fmt"
"fuj-management/go/internal/config"
"fuj-management/go/internal/domain/reconcile"
"fuj-management/go/internal/web"
"fuj-management/go/internal/web/api"
+ "io"
"net/http"
"net/http/httptest"
"strings"
@@ -41,6 +44,8 @@ func (fixtureSources) LoadExceptions(_ context.Context) (map[reconcile.Exception
return nil, nil
}
+func (fixtureSources) FlushCache() (int, error) { return 0, nil }
+
func fixtureHandler(t *testing.T) *api.Handler {
t.Helper()
return &api.Handler{
@@ -55,7 +60,7 @@ func TestHTMLHandlerSmoke(t *testing.T) {
t.Fatalf("NewRenderer: %v", err)
}
b := web.BuildInfo{Version: "v0", Commit: "abc1234", BuildDate: "2026-01-01"}
- h := web.NewHTMLHandler(renderer, b, fixtureHandler(t))
+ h := web.NewHTMLHandler(renderer, b, fixtureHandler(t), web.ActionHandlers{})
cases := []struct {
path string
@@ -65,7 +70,7 @@ func TestHTMLHandlerSmoke(t *testing.T) {
{"/juniors", h.ServeJuniors},
{"/payments", h.ServePayments},
{"/sync-bank", h.ServeSync},
- {"/flush-cache", h.ServeFlushCache},
+ {"/flush-cache", h.ServeFlushCacheGET},
}
for _, tc := range cases {
@@ -99,7 +104,7 @@ func TestAdultsPage(t *testing.T) {
t.Fatalf("NewRenderer: %v", err)
}
b := web.BuildInfo{Version: "v0", Commit: "abc1234", BuildDate: "2026-01-01"}
- h := web.NewHTMLHandler(renderer, b, fixtureHandler(t))
+ h := web.NewHTMLHandler(renderer, b, fixtureHandler(t), web.ActionHandlers{})
req := httptest.NewRequest(http.MethodGet, "/adults", nil)
w := httptest.NewRecorder()
@@ -133,7 +138,7 @@ func TestModalMarkup(t *testing.T) {
t.Fatalf("NewRenderer: %v", err)
}
b := web.BuildInfo{Version: "v0", Commit: "abc1234", BuildDate: "2026-01-01"}
- h := web.NewHTMLHandler(renderer, b, fixtureHandler(t))
+ h := web.NewHTMLHandler(renderer, b, fixtureHandler(t), web.ActionHandlers{})
cases := []struct {
path string
@@ -174,7 +179,7 @@ func TestPaymentsPage(t *testing.T) {
t.Fatalf("NewRenderer: %v", err)
}
b := web.BuildInfo{Version: "v0", Commit: "abc1234", BuildDate: "2026-01-01"}
- h := web.NewHTMLHandler(renderer, b, fixtureHandler(t))
+ h := web.NewHTMLHandler(renderer, b, fixtureHandler(t), web.ActionHandlers{})
req := httptest.NewRequest(http.MethodGet, "/payments", nil)
w := httptest.NewRecorder()
@@ -198,3 +203,135 @@ func TestPaymentsPage(t *testing.T) {
}
}
}
+
+func TestServeQR(t *testing.T) {
+ renderer, err := web.NewRenderer()
+ if err != nil {
+ t.Fatalf("NewRenderer: %v", err)
+ }
+ b := web.BuildInfo{Version: "v0", Commit: "abc1234", BuildDate: "2026-01-01"}
+ h := web.NewHTMLHandler(renderer, b, fixtureHandler(t), web.ActionHandlers{})
+
+ req := httptest.NewRequest(http.MethodGet, "/qr?account=2702008874%2F2010&amount=700&message=Test", nil)
+ w := httptest.NewRecorder()
+ h.ServeQR(w, req)
+
+ if w.Code != http.StatusOK {
+ t.Fatalf("status = %d, want 200", w.Code)
+ }
+ if ct := w.Header().Get("Content-Type"); ct != "image/png" {
+ t.Errorf("Content-Type = %q, want image/png", ct)
+ }
+ // PNG magic bytes: \x89PNG\r\n\x1a\n
+ magic := []byte{0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a}
+ body := w.Body.Bytes()
+ if len(body) < len(magic) || !bytes.Equal(body[:len(magic)], magic) {
+ t.Error("response body does not start with PNG magic bytes")
+ }
+}
+
+func TestServeFlushCacheGET(t *testing.T) {
+ renderer, err := web.NewRenderer()
+ if err != nil {
+ t.Fatalf("NewRenderer: %v", err)
+ }
+ b := web.BuildInfo{Version: "v0", Commit: "abc1234", BuildDate: "2026-01-01"}
+ h := web.NewHTMLHandler(renderer, b, fixtureHandler(t), web.ActionHandlers{})
+
+ req := httptest.NewRequest(http.MethodGet, "/flush-cache", nil)
+ w := httptest.NewRecorder()
+ h.ServeFlushCacheGET(w, req)
+
+ if w.Code != http.StatusOK {
+ t.Fatalf("status = %d, want 200", w.Code)
+ }
+ body := w.Body.String()
+ if !strings.Contains(body, "Flush Cache") {
+ t.Error("body missing Flush Cache heading")
+ }
+ if strings.Contains(body, "file(s) deleted") {
+ t.Error("GET should not show deleted count")
+ }
+}
+
+func TestServeFlushCachePOST(t *testing.T) {
+ renderer, err := web.NewRenderer()
+ if err != nil {
+ t.Fatalf("NewRenderer: %v", err)
+ }
+ b := web.BuildInfo{Version: "v0", Commit: "abc1234", BuildDate: "2026-01-01"}
+ h := web.NewHTMLHandler(renderer, b, fixtureHandler(t), web.ActionHandlers{})
+
+ req := httptest.NewRequest(http.MethodPost, "/flush-cache", nil)
+ w := httptest.NewRecorder()
+ h.ServeFlushCachePOST(w, req)
+
+ if w.Code != http.StatusOK {
+ t.Fatalf("status = %d, want 200", w.Code)
+ }
+ body := w.Body.String()
+ // fixtureSources.FlushCache returns 0
+ if !strings.Contains(body, "file(s) deleted") {
+ t.Error("POST should show deleted count")
+ }
+}
+
+func TestServeSync(t *testing.T) {
+ renderer, err := web.NewRenderer()
+ if err != nil {
+ t.Fatalf("NewRenderer: %v", err)
+ }
+ b := web.BuildInfo{Version: "v0", Commit: "abc1234", BuildDate: "2026-01-01"}
+
+ actions := web.ActionHandlers{
+ BankSync: func(_ context.Context, out io.Writer) error {
+ fmt.Fprintln(out, "=== Sync Fio Transactions ===")
+ fmt.Fprintln(out, "Synced 3 new transaction(s).")
+ fmt.Fprintln(out, "=== Infer Payments ===")
+ fmt.Fprintln(out, "Inferred 2 row(s).")
+ return nil
+ },
+ }
+ h := web.NewHTMLHandler(renderer, b, fixtureHandler(t), actions)
+
+ req := httptest.NewRequest(http.MethodGet, "/sync-bank", nil)
+ w := httptest.NewRecorder()
+ h.ServeSync(w, req)
+
+ if w.Code != http.StatusOK {
+ t.Fatalf("status = %d, want 200", w.Code)
+ }
+ body := w.Body.String()
+ for _, want := range []string{
+ "Sync Bank Data",
+ "Synced 3 new transaction(s).",
+ "Inferred 2 row(s).",
+ "Flush Cache",
+ } {
+ if !strings.Contains(body, want) {
+ t.Errorf("body missing %q", want)
+ }
+ }
+}
+
+func TestServeVersion(t *testing.T) {
+ req := httptest.NewRequest(http.MethodGet, "/api/version", nil)
+ w := httptest.NewRecorder()
+ fixtureHandler(t).ServeVersion(w, req)
+
+ if w.Code != http.StatusOK {
+ t.Fatalf("status = %d, want 200", w.Code)
+ }
+ if ct := w.Header().Get("Content-Type"); !strings.HasPrefix(ct, "application/json") {
+ t.Errorf("Content-Type = %q, want application/json", ct)
+ }
+ var raw map[string]json.RawMessage
+ if err := json.NewDecoder(w.Body).Decode(&raw); err != nil {
+ t.Fatalf("decode JSON: %v", err)
+ }
+ for _, key := range []string{"tag", "commit", "build_date"} {
+ if _, ok := raw[key]; !ok {
+ t.Errorf("JSON response missing key %q", key)
+ }
+ }
+}
diff --git a/go/internal/web/qr.go b/go/internal/web/qr.go
new file mode 100644
index 0000000..7f94704
--- /dev/null
+++ b/go/internal/web/qr.go
@@ -0,0 +1,50 @@
+package web
+
+import (
+ "fmt"
+ "regexp"
+ "strings"
+ "unicode/utf8"
+
+ qrcode "github.com/skip2/go-qrcode"
+)
+
+var validAccount = regexp.MustCompile(`^[A-Z]{2}\d{2,34}$|^\d{1,16}/\d{4}$`)
+
+// BuildSPD builds a Czech QR Platba SPD string, matching Python's qr_code handler.
+// Invalid account falls back to defaultAccount.
+// Amount is clamped to [0, 10_000_000]; non-numeric input becomes "0.00".
+// Message is truncated to 60 runes and stripped of '*' characters.
+func BuildSPD(account, amount, message, defaultAccount string) string {
+ if !validAccount.MatchString(account) {
+ account = defaultAccount
+ }
+
+ var amtStr string
+ var f float64
+ if _, err := fmt.Sscanf(amount, "%f", &f); err != nil || f < 0 || f > 10_000_000 {
+ amtStr = "0.00"
+ } else {
+ amtStr = fmt.Sprintf("%.2f", f)
+ }
+
+ if utf8.RuneCountInString(message) > 60 {
+ runes := []rune(message)
+ message = string(runes[:60])
+ }
+ message = strings.ReplaceAll(message, "*", "")
+
+ var accStr string
+ if parts := strings.SplitN(account, "/", 2); len(parts) == 2 {
+ accStr = parts[0] + "*BC:" + parts[1]
+ } else {
+ accStr = account
+ }
+
+ return fmt.Sprintf("SPD*1.0*ACC:%s*AM:%s*CC:CZK*MSG:%s", accStr, amtStr, message)
+}
+
+// RenderQRCode encodes payload as a PNG QR code (256×256, error correction Medium).
+func RenderQRCode(payload string) ([]byte, error) {
+ return qrcode.Encode(payload, qrcode.Medium, 256)
+}
diff --git a/go/internal/web/qr_test.go b/go/internal/web/qr_test.go
new file mode 100644
index 0000000..38f1f18
--- /dev/null
+++ b/go/internal/web/qr_test.go
@@ -0,0 +1,91 @@
+package web
+
+import (
+ "strings"
+ "testing"
+)
+
+func TestQRBuildSPD(t *testing.T) {
+ const def = "2702008874/2010"
+
+ cases := []struct {
+ name string
+ account string
+ amount string
+ message string
+ want string
+ }{
+ {
+ name: "czech account",
+ account: "2702008874/2010",
+ amount: "700",
+ message: "Test Member: 01/2026",
+ want: "SPD*1.0*ACC:2702008874*BC:2010*AM:700.00*CC:CZK*MSG:Test Member: 01/2026",
+ },
+ {
+ name: "IBAN account",
+ account: "CZ6508000000192000145399",
+ amount: "500",
+ message: "hi",
+ want: "SPD*1.0*ACC:CZ6508000000192000145399*AM:500.00*CC:CZK*MSG:hi",
+ },
+ {
+ name: "invalid account falls back to default",
+ account: "NOTANACCOUNT",
+ amount: "100",
+ message: "x",
+ want: "SPD*1.0*ACC:2702008874*BC:2010*AM:100.00*CC:CZK*MSG:x",
+ },
+ {
+ name: "empty account falls back to default",
+ account: "",
+ amount: "0",
+ message: "",
+ want: "SPD*1.0*ACC:2702008874*BC:2010*AM:0.00*CC:CZK*MSG:",
+ },
+ {
+ name: "negative amount clamped to 0.00",
+ account: def,
+ amount: "-1",
+ message: "",
+ want: "SPD*1.0*ACC:2702008874*BC:2010*AM:0.00*CC:CZK*MSG:",
+ },
+ {
+ name: "amount over 10M clamped to 0.00",
+ account: def,
+ amount: "99999999",
+ message: "",
+ want: "SPD*1.0*ACC:2702008874*BC:2010*AM:0.00*CC:CZK*MSG:",
+ },
+ {
+ name: "non-numeric amount becomes 0.00",
+ account: def,
+ amount: "abc",
+ message: "",
+ want: "SPD*1.0*ACC:2702008874*BC:2010*AM:0.00*CC:CZK*MSG:",
+ },
+ {
+ name: "asterisks stripped from message",
+ account: def,
+ amount: "100",
+ message: "pay*now",
+ want: "SPD*1.0*ACC:2702008874*BC:2010*AM:100.00*CC:CZK*MSG:paynow",
+ },
+ {
+ name: "message truncated to 60 runes",
+ account: def,
+ amount: "0",
+ message: strings.Repeat("á", 65),
+ want: "SPD*1.0*ACC:2702008874*BC:2010*AM:0.00*CC:CZK*MSG:" + strings.Repeat("á", 60),
+ },
+ }
+
+ for _, tc := range cases {
+ t.Run(tc.name, func(t *testing.T) {
+ got := BuildSPD(tc.account, tc.amount, tc.message, def)
+ if got != tc.want {
+ t.Errorf("\ngot: %s\nwant: %s", got, tc.want)
+ }
+ })
+ }
+}
diff --git a/go/internal/web/render.go b/go/internal/web/render.go
index c9ee3a9..b30c3c9 100644
--- a/go/internal/web/render.go
+++ b/go/internal/web/render.go
@@ -37,6 +37,20 @@ type PaymentsPageData struct {
Error string
}
+// SyncPageData is the view model for the /sync-bank HTML page.
+type SyncPageData struct {
+ PageData
+ Output string
+ Success bool
+}
+
+// FlushPageData is the view model for the /flush-cache HTML page.
+type FlushPageData struct {
+ PageData
+ Flushed bool
+ Deleted int
+}
+
// Renderer parses and executes HTML templates from the embedded FS.
type Renderer struct {
tmpls map[string]*template.Template
diff --git a/go/internal/web/server.go b/go/internal/web/server.go
index 624877b..15f7998 100644
--- a/go/internal/web/server.go
+++ b/go/internal/web/server.go
@@ -1,11 +1,13 @@
package web
import (
+ "context"
"fmt"
"fuj-management/go/internal/config"
"fuj-management/go/internal/services/membership"
"fuj-management/go/internal/web/api"
"fuj-management/go/internal/web/middleware"
+ "io"
"io/fs"
"log/slog"
"net/http"
@@ -18,8 +20,16 @@ type BuildInfo struct {
BuildDate string
}
+// ActionHandlers holds function closures for side-effectful operations that
+// require dependencies (fio, sheets) not present on the core API handler.
+type ActionHandlers struct {
+ // BankSync runs sync+infer and writes a human-readable log to out.
+ // nil disables the /sync-bank action (renders an error instead).
+ BankSync func(ctx context.Context, out io.Writer) error
+}
+
// Run registers routes and starts the HTTP server on addr.
-func Run(logger *slog.Logger, addr string, build BuildInfo, sources membership.Sources, cfg config.Config) error {
+func Run(logger *slog.Logger, addr string, build BuildInfo, sources membership.Sources, cfg config.Config, actions ActionHandlers) error {
renderer, err := NewRenderer()
if err != nil {
return fmt.Errorf("init templates: %w", err)
@@ -33,7 +43,7 @@ func Run(logger *slog.Logger, addr string, build BuildInfo, sources membership.S
Config: cfg,
Logger: logger,
}
- hh := NewHTMLHandler(renderer, build, ah)
+ hh := NewHTMLHandler(renderer, build, ah, actions)
staticSubFS, err := fs.Sub(staticFS, "static")
if err != nil {
@@ -50,13 +60,16 @@ func Run(logger *slog.Logger, addr string, build BuildInfo, sources membership.S
mux.HandleFunc("GET /juniors", hh.ServeJuniors)
mux.HandleFunc("GET /payments", hh.ServePayments)
mux.HandleFunc("GET /sync-bank", hh.ServeSync)
- mux.HandleFunc("GET /flush-cache", hh.ServeFlushCache)
+ mux.HandleFunc("GET /flush-cache", hh.ServeFlushCacheGET)
+ mux.HandleFunc("POST /flush-cache", hh.ServeFlushCachePOST)
+ mux.HandleFunc("GET /qr", hh.ServeQR)
// Static files
mux.Handle("/static/", http.StripPrefix("/static/", http.FileServerFS(staticSubFS)))
// JSON API routes
mux.HandleFunc("GET /api/version", ah.ServeVersion)
+ mux.HandleFunc("GET /version", ah.ServeVersion)
mux.HandleFunc("GET /api/adults", ah.ServeAdults)
mux.HandleFunc("GET /api/juniors", ah.ServeJuniors)
mux.HandleFunc("GET /api/payments", ah.ServePayments)
diff --git a/go/internal/web/templates/flush_cache.tmpl b/go/internal/web/templates/flush_cache.tmpl
index a95814e..7dd68bd 100644
--- a/go/internal/web/templates/flush_cache.tmpl
+++ b/go/internal/web/templates/flush_cache.tmpl
@@ -1,5 +1,11 @@
{{define "title"}}Flush Cache{{end}}
{{define "content"}}
Flush Cache
-Coming in M6.6
+{{if .Flushed}}
+ Cache flushed: {{.Deleted}} file(s) deleted.
+{{end}}
+Deletes all cached data files so the next request fetches fresh data from Google Sheets.
+
{{end}}
diff --git a/go/internal/web/templates/sync.tmpl b/go/internal/web/templates/sync.tmpl
index 6042663..3f4f7ba 100644
--- a/go/internal/web/templates/sync.tmpl
+++ b/go/internal/web/templates/sync.tmpl
@@ -1,5 +1,15 @@
{{define "title"}}Sync Bank Data{{end}}
{{define "content"}}
Coming in M6.6
+{{if .Output}} + {{if .Success}} +Sync completed successfully.
+ {{else}} +Sync failed — see log below.
+ {{end}} +{{.Output}}
+{{else}}
+ Fetches Fio transactions for the current year, infers payment details, and flushes the cache.
+{{end}} + {{end}}