Compare commits
9
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
  kacerrandClaude Opus 5.5
|
2c2db60fe7 | ||
|
kacerr
|
1d5a1c95d2 | ||
|
kacerrandClaude Opus 5.5
|
62c6dc2ca0 | ||
|
kacerr
|
23633f8cb2 | ||
|
kacerrandClaude Opus 5.5
|
2d8aada8d6 | ||
|
kacerr
|
14cdbeac21 | ||
|
kacerrandClaude Opus 5.5
|
5b162d0030 | ||
|
kacerr
|
cfdc5cbb2a | ||
|
kacerr
|
e2ae5a7ec4 |
@@ -1,111 +0,0 @@
|
||||
name: Deploy to K8s
|
||||
on:
|
||||
workflow_dispatch:
|
||||
push:
|
||||
branches:
|
||||
- '**'
|
||||
jobs:
|
||||
deploy:
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- name: Checkout
|
||||
uses: actions/checkout@v4
|
||||
|
||||
- name: Debug - print Gitea Actions environment
|
||||
run: |
|
||||
echo "=== All environment variables ==="
|
||||
env | sort
|
||||
echo ""
|
||||
echo "=== GITHUB_* / GITEA_* / ACTIONS_* vars ==="
|
||||
env | grep -E '^(GITHUB|GITEA|ACTIONS)_' | sort
|
||||
|
||||
- name: Install kubectl
|
||||
run: |
|
||||
curl -sfLO "https://dl.k8s.io/release/$(curl -sfL https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
|
||||
install kubectl /usr/local/bin/
|
||||
|
||||
- name: Get Kanidm token from Vault
|
||||
id: vault
|
||||
run: |
|
||||
set -euxo pipefail
|
||||
|
||||
VAULT_AUTH_RESPONSE=$(curl -f --request POST \
|
||||
--data '{"role_id":"${{ secrets.VAULT_ROLE_ID }}","secret_id":"${{ secrets.VAULT_SECRET_ID }}"}' \
|
||||
https://vault.hrajfrisbee.cz/v1/auth/approle/login)
|
||||
|
||||
echo "Vault auth response: $VAULT_AUTH_RESPONSE" >&2
|
||||
VAULT_TOKEN=$(echo "$VAULT_AUTH_RESPONSE" | jq -r '.auth.client_token')
|
||||
|
||||
# Read the kanidm API token
|
||||
SECRET_RESPONSE=$(curl -f \
|
||||
-H "X-Vault-Token: ${VAULT_TOKEN}" \
|
||||
https://vault.hrajfrisbee.cz/v1/secret/data/gitea/gitea-ci)
|
||||
|
||||
echo "Secret response: $SECRET_RESPONSE" >&2
|
||||
API_TOKEN=$(echo "$SECRET_RESPONSE" | jq -r '.data.data.token')
|
||||
|
||||
echo "::add-mask::${API_TOKEN}"
|
||||
echo "api_token=${API_TOKEN}" >> "$GITHUB_OUTPUT"
|
||||
|
||||
- name: Exchange for K8s OIDC token via Kanidm
|
||||
id: k8s
|
||||
run: |
|
||||
API_TOKEN="${{ steps.vault.outputs.api_token }}"
|
||||
echo "api_token length: ${#API_TOKEN}" >&2
|
||||
echo "api_token prefix (first 8 chars): ${API_TOKEN:0:8}..." >&2
|
||||
|
||||
HTTP_BODY=$(mktemp)
|
||||
HTTP_STATUS=$(curl -sS -X POST "https://idm.home.hrajfrisbee.cz/oauth2/token" \
|
||||
-d "grant_type=urn:ietf:params:oauth:grant-type:token-exchange" \
|
||||
-d "client_id=k8s" \
|
||||
-d "subject_token=${API_TOKEN}" \
|
||||
-d "subject_token_type=urn:ietf:params:oauth:token-type:access_token" \
|
||||
-d "audience=k8s" \
|
||||
-d "scope=openid groups" \
|
||||
-o "$HTTP_BODY" -w "%{http_code}")
|
||||
|
||||
echo "HTTP status: $HTTP_STATUS" >&2
|
||||
echo "Response body:" >&2
|
||||
cat "$HTTP_BODY" >&2
|
||||
|
||||
RESPONSE=$(cat "$HTTP_BODY")
|
||||
ID_TOKEN=$(echo "$RESPONSE" | jq -r '.id_token // empty')
|
||||
|
||||
if [ -z "$ID_TOKEN" ]; then
|
||||
echo "::error::Kanidm token exchange failed (HTTP $HTTP_STATUS)"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
echo "::add-mask::${ID_TOKEN}"
|
||||
echo "id_token=${ID_TOKEN}" >> "$GITHUB_OUTPUT"
|
||||
|
||||
# Sanity check
|
||||
# Warning - this is the part that is failing
|
||||
# echo "$ID_TOKEN" | cut -d. -f2 | base64 -d 2>/dev/null | jq '{sub, groups, exp}'
|
||||
|
||||
|
||||
- name: Debug - print environment before kubectl
|
||||
run: env | sort
|
||||
|
||||
- name: Configure kubectl & deploy
|
||||
run: |
|
||||
echo "${{ secrets.K8S_CA_CERT }}" > /tmp/ca.crt
|
||||
|
||||
kubectl config set-cluster mycluster \
|
||||
--server=https://192.168.0.31:6443 \
|
||||
--insecure-skip-tls-verify=true
|
||||
# --certificate-authority=/tmp/ca.crt \
|
||||
|
||||
kubectl config set-credentials gitea-ci \
|
||||
--token="${{ steps.k8s.outputs.id_token }}"
|
||||
|
||||
kubectl config set-context gitea-ci \
|
||||
--cluster=mycluster --user=gitea-ci
|
||||
|
||||
kubectl config use-context gitea-ci
|
||||
|
||||
kubectl auth whoami
|
||||
kubectl get ns
|
||||
|
||||
# your deploy here
|
||||
# kubectl apply -f k8s/
|
||||
@@ -1,5 +1,34 @@
|
||||
# Changelog
|
||||
|
||||
## 2026-10-08 12:16 CEST — feat(go): scheduled bank sync (Go only)
|
||||
|
||||
- The Go server now runs the bank sync (sync → infer → flush cache) by itself at the times in `SYNC_SCHEDULE` (comma-separated `HH:MM`, default `04:00`, `off` disables), read in `SYNC_TZ` (default `Europe/Prague`). Nothing runs at startup; an invalid value stops the server at startup with an error.
|
||||
- Manual `/sync-bank` and scheduled runs share one lock, so two syncs can no longer overlap; a second request gets "a sync is already running".
|
||||
- The page footer shows the last sync since start (time, trigger, ok/FAILED) and the next scheduled run.
|
||||
- The binary embeds the time zone database (`time/tzdata`), since the Alpine image has none.
|
||||
- Deliberately not implemented in the legacy Python app, which is being phased out; recorded in `CLAUDE.md` under "Deliberately Go-only features".
|
||||
- Key files: `go/internal/scheduler/`, `go/internal/services/banksync/runner.go`, `go/cmd/fuj/main.go`, `go/internal/config/config.go`, `go/internal/web/`.
|
||||
|
||||
## 2026-10-08 12:04 CEST — fix(sync): dashboard sync covers the current year plus Nov–Dec of the previous one
|
||||
|
||||
- `/sync-bank` now uses one shared default window in both implementations: 1 November of the previous year to 31 December of the current year. Payments dated around New Year are picked up in January; duplicates are still filtered by Sync ID.
|
||||
- Python previously used a hardcoded `2026-01-01`..`2026-12-31` and would have stopped syncing on 2027-01-01; Go used the current calendar year only.
|
||||
- Added `make sync-year [YEAR=N]` with the same window; `make sync-2026` is kept. The CLI default without flags (last 30 days) is unchanged.
|
||||
- Key files: `go/internal/services/banksync/sync.go` (`DefaultWindow`), `go/cmd/fuj/main.go`, `legacy/scripts/sync_fio_to_sheets.py` (`default_sync_window`), `legacy/app.py`.
|
||||
|
||||
## 2026-10-08 11:53 CEST — feat(fees): adult rates for 2026-07 through 2026-12, default 600
|
||||
|
||||
- Adult default monthly rate (months not in the table): 700 → 600 CZK.
|
||||
- 2026-07 and 2026-08: 600 → 0 CZK; 2026-09 through 2026-12 added at 600 CZK (September and October were previously billed at the old 700 default).
|
||||
- The single-session fee (200 CZK) is now capped at the month's rate, so a 0-rate month is free for one session too.
|
||||
- Mirrored in `go/internal/domain/fees/fees.go` and `legacy/scripts/attendance.py`; three new parity fixtures for `calculate_fee`.
|
||||
|
||||
## 2026-10-08 11:48 CEST — fix(ci): remove kubernetes-deploy workflow that leaked secrets to logs
|
||||
|
||||
- Deleted `.gitea/workflows/kubernetes-deploy.yaml`. It ran on every push to every branch, deployed nothing, and echoed the Vault login response, the Kanidm API token response and the OIDC token response to the job log.
|
||||
- Deployment is handled by `gitops-update.yaml`. Repo secrets `VAULT_ROLE_ID`, `VAULT_SECRET_ID` and `K8S_CA_CERT` are now unused.
|
||||
- Follow-up outside the repo: rotate the Vault AppRole secret and the Kanidm API token, and clear old job logs.
|
||||
|
||||
## 2026-10-08 11:34 CEST — fix(python): return months_to_show from /api/adults and /api/juniors
|
||||
|
||||
- Go already returned `months_to_show` in the JSON API; Python only passed it to its HTML templates. Backported the key so the API contract matches and `make parity` reports 3/3 routes.
|
||||
|
||||
@@ -20,6 +20,12 @@ Until the Python version is retired, **every new feature and every behaviour cha
|
||||
|
||||
Go-only or Python-only changes are fine for things that exist on one side only (build, tooling, HTML/CSS/JS, refactors with no behaviour change).
|
||||
|
||||
### Deliberately Go-only features
|
||||
|
||||
These exist only in the Go app on purpose. Do not port them to the legacy Python app, which is being phased out:
|
||||
|
||||
- **Scheduled bank sync** — the Go server runs sync → infer → flush-cache by itself at the times in `SYNC_SCHEDULE`. Python's multi-worker gunicorn setup would need a cross-process lock for this, which is not worth building in code that is going away. In Python the sync still runs only from `/sync-bank` or the CLI.
|
||||
|
||||
## Key Constraints
|
||||
|
||||
- **PII separation**: Member data (names, emails, payment info) must never be committed to git. Enforce config/data separation from day one.
|
||||
@@ -64,7 +70,7 @@ make web-debug # Same with FLASK_DEBUG=1
|
||||
make test # Run all tests (unittest discover)
|
||||
make test-v # Tests with verbose output
|
||||
make fees # Print fee report from attendance sheet
|
||||
make sync-2026 # Sync Fio bank transactions for 2026 to Google Sheets
|
||||
make sync-year # Sync Fio transactions for the current year plus Nov-Dec of the previous one (YEAR=N to override)
|
||||
make infer # Auto-fill Person/Purpose/Amount columns in payments sheet
|
||||
make reconcile # Print balance report from Google Sheets data
|
||||
make image # Build the legacy Python Docker image
|
||||
@@ -104,10 +110,11 @@ Fio Bank API ──► bank sync ──► Google Sheets (payments
|
||||
|
||||
- `go/cmd/fuj` — CLI entry point; subcommands `server`, `fees`, `reconcile`, `sync`, `infer`, `version`.
|
||||
- `go/cmd/parity` — diffs the JSON API of the Go and Python servers.
|
||||
- `go/internal/config` — sheet IDs, bank accounts, env-driven settings (`CREDENTIALS_PATH`, `CACHE_DIR`, `CACHE_TTL_SECONDS`, `CACHE_API_CHECK_TTL_SECONDS`, `MONTHS_TO_SHOW`, `SERVER_ADDR`, `LOG_LEVEL`, `FIO_API_TOKEN_NEW` / `FIO_API_TOKEN_OLD`).
|
||||
- `go/internal/config` — sheet IDs, bank accounts, env-driven settings (`CREDENTIALS_PATH`, `CACHE_DIR`, `CACHE_TTL_SECONDS`, `CACHE_API_CHECK_TTL_SECONDS`, `MONTHS_TO_SHOW`, `SERVER_ADDR`, `LOG_LEVEL`, `FIO_API_TOKEN_NEW` / `FIO_API_TOKEN_OLD`, `SYNC_SCHEDULE`, `SYNC_TZ`).
|
||||
- `go/internal/domain` — pure logic: `fees` (rates, `CalculateFee`, `CalculateJuniorFee`), `reconcile`, `matching` (name matching, inference), `czech` (normalize, month parsing), `money`, `synch` (sync IDs).
|
||||
- `go/internal/io` — external systems: `attendance` (CSV export), `sheets`, `drive`, `fio` (API + transparent-page scraper), `cache` (file cache). Each has a fake for tests.
|
||||
- `go/internal/services` — `membership` (loading, merged months, fee and reconcile reports) and `banksync` (Fio sync + inference).
|
||||
- `go/internal/services` — `membership` (loading, merged months, fee and reconcile reports) and `banksync` (Fio sync + inference; `Runner` serialises manual and scheduled runs).
|
||||
- `go/internal/scheduler` — runs a job at fixed times of day; used by `fuj server` for the scheduled bank sync.
|
||||
- `go/internal/web` — routes for `/adults`, `/juniors`, `/payments`, `/sync-bank`, `/flush-cache`, `/qr`, `/version`, `/api/*`; `templates/` and `static/` are embedded.
|
||||
- `go/tests` — parity tests and the scrubbed fixture corpus captured from Python.
|
||||
|
||||
@@ -126,13 +133,13 @@ Fio Bank API ──► bank sync ──► Google Sheets (payments
|
||||
### Member tiers
|
||||
|
||||
Tiers are set in column B of the attendance sheet:
|
||||
- `A` — Adult, pays fees (per-month rate from `AdultFeeMonthlyRate` / `ADULT_FEE_MONTHLY_RATE`, fallback 700 CZK for 2+ sessions; 200 CZK for exactly 1)
|
||||
- `A` — Adult, pays fees (per-month rate from `AdultFeeMonthlyRate` / `ADULT_FEE_MONTHLY_RATE`, fallback 600 CZK for 2+ sessions; 200 CZK for exactly 1, capped at the month's rate)
|
||||
- `J` — Junior attending adult practices; their attendance is merged with the junior sheet
|
||||
- `X` — Excluded from junior fee calculation (coaches, etc.)
|
||||
|
||||
### Fee calculation
|
||||
|
||||
- Adults: 0 sessions → 0, 1 session → 200 CZK, 2+ sessions → monthly rate (default 700 CZK)
|
||||
- Adults: 0 sessions → 0, 1 session → 200 CZK (never more than the month's rate, so a 0-rate month is free), 2+ sessions → monthly rate (default 600 CZK)
|
||||
- Juniors: 0 → 0, 1 → `"?"` (manual review required), 2+ → monthly rate (default 500 CZK)
|
||||
- Per-member per-month overrides live in the `exceptions` tab of the payments sheet (columns: Name, Period YYYY-MM, Amount, Note). Exceptions are keyed by `(normalize(name), normalize(period))`.
|
||||
|
||||
@@ -144,6 +151,13 @@ Tiers are set in column B of the attendance sheet:
|
||||
|
||||
Both implementations check the Drive API `modifiedTime` and serve a cached JSON file when the sheet hasn't changed, falling back to 5-minute TTL buckets when the Drive API is unavailable. Go: `go/internal/io/cache`, files in `tmp/go/` (`CACHE_DIR`). Python: `get_cached_data()` in `legacy/app.py`, files in `legacy/tmp/`, warmed up at startup (`warmup_cache()`). Flush via `/flush-cache` (POST).
|
||||
|
||||
### Bank sync
|
||||
|
||||
- Manual: open `/sync-bank` (both apps) or run `fuj sync` + `fuj infer` / `make sync-year` + `make infer`.
|
||||
- Scheduled (Go server only): at each time in `SYNC_SCHEDULE` (comma-separated `HH:MM`, default `04:00`; `off` disables) read in `SYNC_TZ` (default `Europe/Prague`). Nothing runs at startup. Manual and scheduled runs share one lock and never overlap. The page footer shows the last run since start and the next one.
|
||||
- Both use the same window: 1 November of the previous year to 31 December of the current year; rows are de-duplicated by Sync ID.
|
||||
- The schedule runs per process: keep the deployment at one replica, and note that a local `make web-go` with real credentials also syncs at the scheduled time unless `SYNC_SCHEDULE=off`.
|
||||
|
||||
### Payments sheet columns
|
||||
|
||||
`Date | Amount | manual fix | Person | Purpose | Inferred Amount | Sender | VS | Message | Bank ID | Sync ID`
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
.PHONY: help fees match web web-py web-debug web-go go-build go-test go-test-all go-parity go-run go-sync-debug go-lint capture-fixtures parity image run sync sync-2026 test test-v docs
|
||||
.PHONY: help fees match web web-py web-debug web-go go-build go-test go-test-all go-parity go-run go-sync-debug go-lint capture-fixtures parity image run sync sync-2026 sync-year test test-v docs
|
||||
|
||||
# Legacy Python implementation lives in legacy/ (Go in go/ is primary).
|
||||
LEGACY := legacy
|
||||
@@ -39,6 +39,7 @@ help:
|
||||
@echo " make sync - Sync Fio transactions to Google Sheets"
|
||||
@echo " make sync-2025 - Sync Fio transactions for Q4 2025 (Oct-Dec)"
|
||||
@echo " make sync-2026 - Sync Fio transactions for the whole year of 2026"
|
||||
@echo " make sync-year [YEAR=N] - Sync Fio transactions for YEAR plus Nov-Dec of the year before (default: current year)"
|
||||
@echo " make sync-debug [DAYS=N] - Dry-run Python sync with Fio diagnostics and txn table (default DAYS=30)"
|
||||
@echo " make infer - Infer payment details (Person, Purpose, Amount) in the sheet"
|
||||
@echo " make reconcile - Show balance report using Google Sheets data"
|
||||
@@ -130,6 +131,10 @@ sync-2025: $(PYTHON)
|
||||
sync-2026: $(PYTHON)
|
||||
$(PYTHON) $(LEGACY)/scripts/sync_fio_to_sheets.py --credentials $(CREDENTIALS) --from 2026-01-01 --to 2026-12-31 --sort-by-date
|
||||
|
||||
YEAR ?= $(shell date +%Y)
|
||||
sync-year: $(PYTHON)
|
||||
$(PYTHON) $(LEGACY)/scripts/sync_fio_to_sheets.py --credentials $(CREDENTIALS) --from $(shell expr $(YEAR) - 1)-11-01 --to $(YEAR)-12-31 --sort-by-date
|
||||
|
||||
sync-debug: $(PYTHON) ## Dry-run Python sync with Fio diagnostics and txn table (default DAYS=30)
|
||||
$(PYTHON) $(LEGACY)/scripts/sync_fio_to_sheets.py --credentials $(CREDENTIALS) --days $(DAYS) --dry-run --print-fio-table
|
||||
|
||||
|
||||
@@ -182,7 +182,7 @@ fuj-management/
|
||||
│
|
||||
├── .gitea/workflows/
|
||||
│ ├── build.yaml # CI: build + push Docker image
|
||||
│ └── kubernetes-deploy.yaml # CD: deploy to K8s cluster
|
||||
│ └── gitops-update.yaml # CD: open image-update PR in home-kubernetes
|
||||
│
|
||||
├── .secret/ # (gitignored) API credentials
|
||||
├── docs/ # Project documentation
|
||||
|
||||
@@ -129,32 +129,27 @@ The project uses two Gitea Actions workflows:
|
||||
|
||||
**Tag resolution**: Uses the git tag name. For manual dispatch, uses the provided input.
|
||||
|
||||
#### 2. Deploy to Kubernetes (`kubernetes-deploy.yaml`)
|
||||
#### 2. GitOps image update (`gitops-update.yaml`)
|
||||
|
||||
**Triggers**:
|
||||
- Push to any branch
|
||||
- Manual dispatch
|
||||
- Completion of a successful "Build and Push" run
|
||||
- Manual dispatch (with `tag`, `dry_run` and `uh_cli_version` inputs)
|
||||
|
||||
**Steps**:
|
||||
1. Checkout code
|
||||
2. Install kubectl
|
||||
3. Retrieve Kanidm token from HashiCorp Vault:
|
||||
- Authenticate to Vault via AppRole (`VAULT_ROLE_ID` / `VAULT_SECRET_ID`)
|
||||
- Fetch API token from `secret/data/gitea/gitea-ci`
|
||||
4. Exchange API token for K8s OIDC token via Kanidm:
|
||||
- POST to `https://idm.home.hrajfrisbee.cz/oauth2/token`
|
||||
- Token exchange using `urn:ietf:params:oauth:grant-type:token-exchange`
|
||||
5. Configure kubectl with the OIDC token
|
||||
6. Run `kubectl auth whoami` and `kubectl get ns` (deploy commands are commented out — WIP)
|
||||
1. Install `tea` and `uh-cli`
|
||||
2. Resolve the image tag of the Go image that was just built
|
||||
3. Open a PR in `kacerr/home-kubernetes` bumping the `fuj-management` Deployment (namespace `fuj`) to that image
|
||||
|
||||
The cluster picks the change up once that PR is merged. CI does not talk to the cluster directly.
|
||||
|
||||
> The earlier `kubernetes-deploy.yaml` workflow (Vault → Kanidm → `kubectl`) was removed on 2026-10-08. It never deployed anything and printed credentials to the job log.
|
||||
|
||||
**Required secrets**:
|
||||
|
||||
| Secret | Purpose |
|
||||
|--------|---------|
|
||||
| `REGISTRY_TOKEN` | Docker registry authentication |
|
||||
| `VAULT_ROLE_ID` | HashiCorp Vault AppRole role ID |
|
||||
| `VAULT_SECRET_ID` | HashiCorp Vault AppRole secret ID |
|
||||
| `K8S_CA_CERT` | Kubernetes cluster CA certificate |
|
||||
| `GITOPS_TOKEN` | Gitea token with write and PR access to `home-kubernetes` |
|
||||
|
||||
### Infrastructure Topology
|
||||
|
||||
@@ -164,8 +159,7 @@ Gitea (git push / tag)
|
||||
├── build.yaml → Docker Build → Gitea Container Registry
|
||||
│ (gitea.home.hrajfrisbee.cz)
|
||||
│
|
||||
└── kubernetes-deploy.yaml → Vault → Kanidm → K8s Cluster
|
||||
(192.168.0.31:6443)
|
||||
└── gitops-update.yaml → PR in home-kubernetes → K8s Cluster
|
||||
```
|
||||
|
||||
This is a self-hosted infrastructure stack:
|
||||
|
||||
@@ -30,20 +30,29 @@ before new feature work starts. Companion to the Go rewrite tracker,
|
||||
|
||||
## Fix first
|
||||
|
||||
- [ ] **T1** Remove the secret leak in `.gitea/workflows/kubernetes-deploy.yaml`.
|
||||
- [x] **T1** Remove the secret leak in `.gitea/workflows/kubernetes-deploy.yaml`.
|
||||
Workflow deleted on 2026-10-08. Still open for the owner: rotate the
|
||||
credentials and remove the now-unused repo secrets (see below).
|
||||
- It runs on every push to every branch and deploys nothing.
|
||||
- It echoes the raw Vault login response, the Kanidm token response and the
|
||||
OIDC token response body to the log, and dumps the environment twice.
|
||||
- It uses `--insecure-skip-tls-verify=true`.
|
||||
- Delete or disable the workflow. Rotate the Vault AppRole secret and the
|
||||
Kanidm API token if anyone else can read the CI logs.
|
||||
- [ ] **T2** Confirm the fee rates for 2026-09 onward.
|
||||
- After deletion the repo secrets `VAULT_ROLE_ID`, `VAULT_SECRET_ID` and
|
||||
`K8S_CA_CERT` are unused and can be removed. Old job logs still contain
|
||||
the leaked tokens until they are deleted or expire.
|
||||
- [x] **T2** Confirm the fee rates for 2026-09 onward. Done 2026-10-08:
|
||||
adult default 600, 2026-07/08 at 0, 2026-09 to 2026-12 at 600. Junior
|
||||
rates were not changed.
|
||||
- `ADULT_FEE_MONTHLY_RATE` ends at 2026-08 in `scripts/attendance.py` and
|
||||
`go/internal/domain/fees/fees.go`.
|
||||
- September and October 2026 are billed at the defaults: 700 CZK adults,
|
||||
500 CZK juniors.
|
||||
- If those are not the intended rates, add the months in both files.
|
||||
- [ ] **T3** Remove the hardcoded 2026 window from Python `/sync-bank`
|
||||
- [x] **T3** Done 2026-10-08, extended: both dashboards now sync the
|
||||
current year plus November–December of the previous one. Original task:
|
||||
remove the hardcoded 2026 window from Python `/sync-bank`
|
||||
(`app.py`, the `sync_to_sheets` call with `2026-01-01` / `2026-12-31`).
|
||||
- It stops picking up transactions on 2027-01-01. Go already uses the
|
||||
current year.
|
||||
@@ -127,7 +136,9 @@ before new feature work starts. Companion to the Go rewrite tracker,
|
||||
- `warmup_cache()` runs at import of `app.py`, so `make test` makes real
|
||||
Drive and Sheets read calls and needs the credentials file.
|
||||
- Moot if Python is retired.
|
||||
- [ ] **T18** Set the time zone in the Go container.
|
||||
- [ ] **T18** Set the time zone in the Go container. Partly addressed
|
||||
2026-10-08: the binary now embeds the zone database and the scheduled sync
|
||||
uses `SYNC_TZ`; the "current month" logic below is still open.
|
||||
- The image has no time zone configured, so `time.Now()` is UTC and the
|
||||
"current month" flips one to two hours late at month boundaries.
|
||||
- The Python image sets `Europe/Prague`.
|
||||
@@ -152,6 +163,12 @@ Plan: [2026-10-08-1103-api-parity-vs-months-to-show.md](2026-10-08-1103-api-pari
|
||||
dropped leading zeros. New rows now carry a text marker; existing rows are
|
||||
left as they are and are read correctly either way.
|
||||
|
||||
## Features added since the audit
|
||||
|
||||
- 2026-10-08 — Scheduled bank sync in the Go server, deliberately Go-only.
|
||||
Plan: [2026-10-08-1216-scheduled-bank-sync.md](2026-10-08-1216-scheduled-bank-sync.md).
|
||||
It also added a lock so two syncs cannot overlap (relevant to T8).
|
||||
|
||||
## Notes & decisions
|
||||
|
||||
(Add entries as you go. Format: `YYYY-MM-DD — short note`.)
|
||||
|
||||
@@ -0,0 +1,134 @@
|
||||
# Scheduled bank sync in the Go server (Go only)
|
||||
|
||||
## Context
|
||||
|
||||
Bank synchronization only runs when someone opens `/sync-bank`; the payments
|
||||
sheet is as fresh as the last click. The Go server should run the same
|
||||
sync → infer → flush-cache sequence by itself on a configured schedule,
|
||||
defaulting to once a day.
|
||||
|
||||
Decisions already made:
|
||||
|
||||
- **Go only.** Deliberately not implemented in the legacy Python app, which is
|
||||
being phased out (gunicorn's multi-worker model would also need a
|
||||
cross-process lock). This is recorded as an explicit exception to the dual
|
||||
implementation rule.
|
||||
- **Schedule format:** one or more times of day. On by default, once a day.
|
||||
|
||||
## Behaviour
|
||||
|
||||
- `SYNC_SCHEDULE` — comma-separated `HH:MM` times, default `04:00`.
|
||||
`off` disables the scheduler. An invalid value makes `fuj server` exit at
|
||||
startup with a clear error.
|
||||
- `SYNC_TZ` — IANA zone the times are read in, default `Europe/Prague`.
|
||||
The binary embeds the zone database (`import _ "time/tzdata"`), because the
|
||||
Alpine image has none.
|
||||
- At each scheduled time the server runs exactly what `/sync-bank` runs
|
||||
(`banksync.DefaultWindow`, `SyncToSheets`, `InferPayments`, cache flush),
|
||||
with a 10-minute timeout, and logs start, result and row counts via `slog`.
|
||||
- Nothing runs at startup; a restart only recomputes the next run time.
|
||||
- A scheduled run and a manual `/sync-bank` can no longer overlap: both go
|
||||
through one mutex. If a sync is already running, the manual page shows
|
||||
"a sync is already running" and a scheduled run is skipped with a log line.
|
||||
(This also closes today's gap where two overlapping manual runs could append
|
||||
the same rows.)
|
||||
- The footer of every page shows the last sync since the server started:
|
||||
time, trigger (scheduled / manual), ok or failed, and the next scheduled
|
||||
run. Status is in memory only and resets on restart.
|
||||
|
||||
## Implementation
|
||||
|
||||
Branch `feat/scheduled-bank-sync` off `main`; MR via `tea`.
|
||||
|
||||
1. **Config** — `go/internal/config/config.go`
|
||||
- Add `SyncSchedule []TimeOfDay` and `SyncLocation *time.Location` to
|
||||
`Config`.
|
||||
- Add `ParseSyncSchedule(s string) ([]TimeOfDay, error)` (`"off"` → empty,
|
||||
sorted, de-duplicated, rejects anything not `HH:MM`) and a
|
||||
`LoadSyncSchedule() (…, error)` reading `SYNC_SCHEDULE` / `SYNC_TZ`.
|
||||
`Load()` keeps its signature; `serverCmd` calls the new loader and exits
|
||||
on error.
|
||||
- New `config_test.go` for the parser (first tests in this package).
|
||||
|
||||
2. **Scheduler** — new package `go/internal/scheduler`
|
||||
- `Next(now time.Time, times []TimeOfDay, loc *time.Location) time.Time` —
|
||||
pure; builds candidates with `time.Date` in `loc` for today and tomorrow
|
||||
and returns the earliest one strictly after `now` (handles DST days).
|
||||
- `Run(ctx, times, loc, logger, job func(context.Context))` — loop:
|
||||
compute `Next`, wait on a timer or `ctx.Done()`, call `job`.
|
||||
- Tests: `Next` table test (before/after today's time, multiple times,
|
||||
midnight rollover, the two DST switch days in Europe/Prague); `Run` with
|
||||
a cancelled context returns.
|
||||
|
||||
3. **Sync runner with lock and status** — new
|
||||
`go/internal/services/banksync/runner.go`
|
||||
- `Runner` wraps the existing sync+infer function (moved out of the
|
||||
closure in `go/cmd/fuj/main.go`) with a `sync.Mutex` (`TryLock`) and
|
||||
records `Status{Started, Finished, Trigger, Err}`.
|
||||
- `Run(ctx, trigger string, out io.Writer) error` returns `ErrBusy` when a
|
||||
run is in progress. `Last() (Status, bool)` for display.
|
||||
- Tests with a fake job: status recorded, error recorded, second
|
||||
concurrent call gets `ErrBusy`.
|
||||
|
||||
4. **Wiring** — `go/cmd/fuj/main.go`
|
||||
- Add `import _ "time/tzdata"`.
|
||||
- Build one `Runner`; `ActionHandlers.BankSync` calls
|
||||
`runner.Run(ctx, "manual", out)` (signature unchanged, so
|
||||
`TestServeSync` keeps working).
|
||||
- If the schedule is non-empty, start `go scheduler.Run(...)` whose job
|
||||
calls `runner.Run(ctx, "scheduled", &buf)` with a 10-minute timeout, then
|
||||
`sources.FlushCache()`, and logs the outcome. Log the schedule and next
|
||||
run at startup, or "scheduled sync disabled".
|
||||
|
||||
5. **Display** — `go/internal/web`
|
||||
- `ActionHandlers` gains optional `SyncInfo func() string` (last + next run
|
||||
as one line). `PageData` gains `SyncInfo string`; add a small
|
||||
`h.page(active)` helper in `html_handler.go` and use it where
|
||||
`PageData{Active: …, Build: h.build}` is built today.
|
||||
- `templates/partials/footer.tmpl`: append the line when non-empty.
|
||||
- `templates/sync.tmpl`: fix the description, which still says "current
|
||||
year" (stale since the window change).
|
||||
- Extend `html_handler_test.go`: footer shows the info when provided,
|
||||
nothing extra when not.
|
||||
|
||||
6. **Docs and notes**
|
||||
- `CLAUDE.md`: document `SYNC_SCHEDULE` / `SYNC_TZ` under the Go config
|
||||
list and the commands/architecture text; under "Dual implementation
|
||||
rule" add a "Deliberately Go-only" list with this feature and the reason.
|
||||
- `legacy/app.py`: one comment above `sync_bank()` stating that scheduled
|
||||
sync exists only in Go, on purpose.
|
||||
- `CHANGELOG.md` entry; copy this plan to
|
||||
`docs/plans/2026-10-08-HHMM-scheduled-bank-sync.md`.
|
||||
- Add a note to the cleanup task list: T18 (time zone) is addressed for
|
||||
the scheduler only; the "current month" logic still uses the process
|
||||
clock.
|
||||
|
||||
No new dependencies. No Dockerfile change. No change to parity fixtures or
|
||||
the JSON API.
|
||||
|
||||
## Deployment notes (for the MR description)
|
||||
|
||||
- On by default at 04:00 Europe/Prague. Set `SYNC_SCHEDULE=off` to disable.
|
||||
- A locally running `make web-go` with real credentials will also sync at
|
||||
that time.
|
||||
- With more than one replica each pod would run its own schedule; the
|
||||
deployment must stay at one replica (or disable the schedule on extras).
|
||||
- Without `FIO_API_TOKEN_*` the sync scrapes the transparent-account pages,
|
||||
as today.
|
||||
|
||||
## Verification
|
||||
|
||||
1. `make go-test-all` and `make go-lint` equivalent (`go vet`, `gofmt -l`);
|
||||
`make test` to confirm Python is untouched.
|
||||
2. Start `fuj server` with `SYNC_SCHEDULE=off` → log says disabled, footer
|
||||
shows no schedule.
|
||||
3. Start with an invalid value (`SYNC_SCHEDULE=25:00`) → exits with an error.
|
||||
4. Live check: start with `SYNC_SCHEDULE` set two minutes ahead and watch the
|
||||
log for the scheduled run and the footer for the status line. **This
|
||||
performs one real sync** against the payments sheet (currently one pending
|
||||
transaction would be appended) — the same thing a click on `/sync-bank`
|
||||
does.
|
||||
5. While that run is in progress, or with a test job, confirm a second
|
||||
trigger reports "already running".
|
||||
6. Build the Go image and confirm the schedule log line shows the Prague
|
||||
zone inside the container (proves the embedded zone data works).
|
||||
+81
-5
@@ -1,20 +1,25 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"errors"
|
||||
"flag"
|
||||
"fmt"
|
||||
"fuj-management/go/internal/config"
|
||||
"fuj-management/go/internal/io/fio"
|
||||
"fuj-management/go/internal/io/sheets"
|
||||
"fuj-management/go/internal/logging"
|
||||
"fuj-management/go/internal/scheduler"
|
||||
"fuj-management/go/internal/services/banksync"
|
||||
"fuj-management/go/internal/services/membership"
|
||||
"fuj-management/go/internal/web"
|
||||
"io"
|
||||
"log/slog"
|
||||
"os"
|
||||
"strings"
|
||||
"time"
|
||||
_ "time/tzdata" // the container image has no zone database; SYNC_TZ needs one
|
||||
)
|
||||
|
||||
// Injected at build time via -ldflags "-X main.version=... -X main.commit=... -X main.buildDate=..."
|
||||
@@ -90,11 +95,17 @@ func serverCmd(args []string) {
|
||||
}
|
||||
fioClients := buildFioClients(cfg)
|
||||
|
||||
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)
|
||||
syncTimes, syncLoc, err := config.LoadSyncSchedule()
|
||||
if err != nil {
|
||||
fmt.Fprintf(os.Stderr, "fuj server: %v\n", err)
|
||||
os.Exit(2)
|
||||
}
|
||||
|
||||
// One runner serves both the /sync-bank page and the scheduler, so the two
|
||||
// can never run at the same time.
|
||||
runner := banksync.NewRunner(
|
||||
func(ctx context.Context, out io.Writer) error {
|
||||
from, to := banksync.DefaultWindow(time.Now())
|
||||
|
||||
fmt.Fprintln(out, "=== Sync Fio Transactions ===")
|
||||
n, err := banksync.SyncToSheets(ctx, config.PaymentsSheetID, fioClients, sheetsCli,
|
||||
@@ -112,6 +123,22 @@ func serverCmd(args []string) {
|
||||
fmt.Fprintf(out, "Inferred %d row(s).\n", n)
|
||||
return nil
|
||||
},
|
||||
)
|
||||
|
||||
actions := web.ActionHandlers{
|
||||
BankSync: func(ctx context.Context, out io.Writer) error {
|
||||
return runner.Run(ctx, "manual", out)
|
||||
},
|
||||
SyncInfo: func() string { return syncInfo(runner, syncTimes, syncLoc, time.Now()) },
|
||||
}
|
||||
|
||||
if len(syncTimes) == 0 {
|
||||
logger.Info("scheduled bank sync disabled (SYNC_SCHEDULE=off)")
|
||||
} else {
|
||||
logger.Info("scheduled bank sync enabled", "times", fmt.Sprint(syncTimes), "tz", syncLoc.String())
|
||||
go scheduler.Run(ctx, syncTimes, syncLoc, logger, func(ctx context.Context) {
|
||||
scheduledSync(ctx, logger, runner, sources)
|
||||
})
|
||||
}
|
||||
|
||||
build := web.BuildInfo{Version: version, Commit: commit, BuildDate: buildDate}
|
||||
@@ -122,6 +149,55 @@ func serverCmd(args []string) {
|
||||
}
|
||||
}
|
||||
|
||||
// scheduledSyncTimeout bounds one scheduled run (two bank fetches plus sheet writes).
|
||||
const scheduledSyncTimeout = 10 * time.Minute
|
||||
|
||||
// scheduledSync is the scheduler's job: the same sync → infer → flush-cache
|
||||
// sequence as the /sync-bank page, with the outcome written to the log.
|
||||
func scheduledSync(ctx context.Context, logger *slog.Logger, runner *banksync.Runner, sources membership.Sources) {
|
||||
ctx, cancel := context.WithTimeout(ctx, scheduledSyncTimeout)
|
||||
defer cancel()
|
||||
|
||||
logger.Info("scheduled bank sync starting")
|
||||
var buf bytes.Buffer
|
||||
err := runner.Run(ctx, "scheduled", &buf)
|
||||
if errors.Is(err, banksync.ErrBusy) {
|
||||
logger.Warn("scheduled bank sync skipped: a sync is already running")
|
||||
return
|
||||
}
|
||||
output := strings.Join(strings.Fields(buf.String()), " ")
|
||||
if _, ferr := sources.FlushCache(); ferr != nil {
|
||||
logger.Error("scheduled bank sync: cache flush failed", "err", ferr)
|
||||
}
|
||||
if err != nil {
|
||||
logger.Error("scheduled bank sync failed", "err", err, "output", output)
|
||||
return
|
||||
}
|
||||
logger.Info("scheduled bank sync finished", "output", output)
|
||||
}
|
||||
|
||||
// syncInfo renders the footer line: the last run since the server started
|
||||
// and the next scheduled one.
|
||||
func syncInfo(runner *banksync.Runner, times []scheduler.TimeOfDay, loc *time.Location, now time.Time) string {
|
||||
const layout = "2006-01-02 15:04"
|
||||
var parts []string
|
||||
if st, ok := runner.Last(); ok {
|
||||
result := "ok"
|
||||
if st.Err != nil {
|
||||
result = "FAILED"
|
||||
}
|
||||
parts = append(parts, fmt.Sprintf("last sync %s (%s) %s", st.Finished.In(loc).Format(layout), st.Trigger, result))
|
||||
} else {
|
||||
parts = append(parts, "no sync since start")
|
||||
}
|
||||
if next := scheduler.Next(now, times, loc); !next.IsZero() {
|
||||
parts = append(parts, "next "+next.Format(layout))
|
||||
} else {
|
||||
parts = append(parts, "scheduled sync off")
|
||||
}
|
||||
return strings.Join(parts, " | ")
|
||||
}
|
||||
|
||||
func feesCmd(args []string) {
|
||||
fs := flag.NewFlagSet("fees", flag.ExitOnError)
|
||||
fs.Usage = func() {
|
||||
|
||||
@@ -0,0 +1,35 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fuj-management/go/internal/scheduler"
|
||||
"fuj-management/go/internal/services/banksync"
|
||||
"io"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
func TestSyncInfo(t *testing.T) {
|
||||
now := time.Date(2026, 10, 8, 12, 0, 0, 0, time.UTC)
|
||||
four := []scheduler.TimeOfDay{{Hour: 4}}
|
||||
|
||||
ok := banksync.NewRunner(func(context.Context, io.Writer) error { return nil })
|
||||
if got := syncInfo(ok, four, time.UTC, now); got != "no sync since start | next 2026-10-09 04:00" {
|
||||
t.Errorf("before any run: %q", got)
|
||||
}
|
||||
if err := ok.Run(context.Background(), "scheduled", io.Discard); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
got := syncInfo(ok, nil, time.UTC, now)
|
||||
if !strings.HasPrefix(got, "last sync ") || !strings.HasSuffix(got, "(scheduled) ok | scheduled sync off") {
|
||||
t.Errorf("after ok run, schedule off: %q", got)
|
||||
}
|
||||
|
||||
bad := banksync.NewRunner(func(context.Context, io.Writer) error { return errors.New("boom") })
|
||||
_ = bad.Run(context.Background(), "manual", io.Discard)
|
||||
if got := syncInfo(bad, four, time.UTC, now); !strings.Contains(got, "(manual) FAILED | next 2026-10-09 04:00") {
|
||||
t.Errorf("after failed run: %q", got)
|
||||
}
|
||||
}
|
||||
@@ -1,6 +1,8 @@
|
||||
package config
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"fuj-management/go/internal/scheduler"
|
||||
"os"
|
||||
"strconv"
|
||||
"strings"
|
||||
@@ -92,6 +94,28 @@ func Load() Config {
|
||||
}
|
||||
}
|
||||
|
||||
// Scheduled bank sync defaults (Go server only; the legacy Python app has no scheduler).
|
||||
const (
|
||||
DefaultSyncSchedule = "04:00" // SYNC_SCHEDULE: comma-separated HH:MM times, or "off"
|
||||
DefaultSyncTimezone = "Europe/Prague" // SYNC_TZ: IANA zone the schedule is read in
|
||||
)
|
||||
|
||||
// LoadSyncSchedule reads SYNC_SCHEDULE and SYNC_TZ. An empty schedule means
|
||||
// the scheduled sync is disabled. Resolving the zone needs a zone database:
|
||||
// the server binary embeds one via time/tzdata.
|
||||
func LoadSyncSchedule() ([]scheduler.TimeOfDay, *time.Location, error) {
|
||||
times, err := scheduler.ParseTimes(env("SYNC_SCHEDULE", DefaultSyncSchedule))
|
||||
if err != nil {
|
||||
return nil, nil, fmt.Errorf("SYNC_SCHEDULE: %w", err)
|
||||
}
|
||||
tz := env("SYNC_TZ", DefaultSyncTimezone)
|
||||
loc, err := time.LoadLocation(tz)
|
||||
if err != nil {
|
||||
return nil, nil, fmt.Errorf("SYNC_TZ: unknown time zone %q", tz)
|
||||
}
|
||||
return times, loc, nil
|
||||
}
|
||||
|
||||
// IBANAccountNum extracts the bare account number from a Czech IBAN.
|
||||
// "CZ8520100000002800359168" → "2800359168"
|
||||
// Structure: CZ(2 check)(4 bank code)(16 zero-padded account).
|
||||
|
||||
@@ -0,0 +1,45 @@
|
||||
package config
|
||||
|
||||
import (
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestLoadSyncSchedule(t *testing.T) {
|
||||
cases := []struct {
|
||||
name, schedule, tz string
|
||||
wantTimes int
|
||||
wantZone string
|
||||
wantErr bool
|
||||
}{
|
||||
{"defaults", "", "", 1, "Europe/Prague", false},
|
||||
{"two times", "06:00,18:00", "", 2, "Europe/Prague", false},
|
||||
{"off", "off", "", 0, "Europe/Prague", false},
|
||||
{"other zone", "04:00", "UTC", 1, "UTC", false},
|
||||
{"bad time", "25:00", "", 0, "", true},
|
||||
{"bad zone", "04:00", "Mars/Olympus", 0, "", true},
|
||||
}
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
t.Setenv("SYNC_SCHEDULE", tc.schedule)
|
||||
t.Setenv("SYNC_TZ", tc.tz)
|
||||
times, loc, err := LoadSyncSchedule()
|
||||
if (err != nil) != tc.wantErr {
|
||||
t.Fatalf("err = %v, wantErr %v", err, tc.wantErr)
|
||||
}
|
||||
if tc.wantErr {
|
||||
return
|
||||
}
|
||||
if len(times) != tc.wantTimes {
|
||||
t.Errorf("times = %v, want %d entries", times, tc.wantTimes)
|
||||
}
|
||||
if loc.String() != tc.wantZone {
|
||||
t.Errorf("zone = %s, want %s", loc, tc.wantZone)
|
||||
}
|
||||
})
|
||||
}
|
||||
t.Setenv("SYNC_SCHEDULE", "")
|
||||
t.Setenv("SYNC_TZ", "")
|
||||
if times, _, _ := LoadSyncSchedule(); len(times) != 1 || times[0].String() != DefaultSyncSchedule {
|
||||
t.Errorf("default schedule = %v, want [%s]", times, DefaultSyncSchedule)
|
||||
}
|
||||
}
|
||||
@@ -2,7 +2,7 @@
|
||||
package fees
|
||||
|
||||
const (
|
||||
AdultFeeDefault = 700 // CZK fallback for 2+ practices when month not in AdultFeeMonthlyRate
|
||||
AdultFeeDefault = 600 // CZK fallback for 2+ practices when month not in AdultFeeMonthlyRate
|
||||
AdultFeeSingle = 200 // CZK for exactly 1 practice
|
||||
)
|
||||
|
||||
@@ -11,24 +11,27 @@ const (
|
||||
var AdultFeeMonthlyRate = map[string]int{
|
||||
"2025-09": 750, "2025-10": 750, "2025-11": 750, "2025-12": 750,
|
||||
"2026-01": 750, "2026-02": 750, "2026-03": 350,
|
||||
"2026-04": 700, "2026-05": 450, "2026-06": 600, "2026-07": 600, "2026-08": 600,
|
||||
"2026-04": 700, "2026-05": 450, "2026-06": 600, "2026-07": 0, "2026-08": 0,
|
||||
"2026-09": 600, "2026-10": 600, "2026-11": 600, "2026-12": 600,
|
||||
}
|
||||
|
||||
// CalculateFee returns the adult fee in CZK for attendanceCount practices in
|
||||
// the given monthKey (format "YYYY-MM").
|
||||
//
|
||||
// 0 practices → 0
|
||||
// 1 practice → AdultFeeSingle (200)
|
||||
// 1 practice → AdultFeeSingle (200), capped at the month's rate so a
|
||||
// 0-rate month is free for everyone
|
||||
// 2+ → AdultFeeMonthlyRate[monthKey] or AdultFeeDefault
|
||||
func CalculateFee(attendanceCount int, monthKey string) int {
|
||||
if attendanceCount == 0 {
|
||||
return 0
|
||||
}
|
||||
rate, ok := AdultFeeMonthlyRate[monthKey]
|
||||
if !ok {
|
||||
rate = AdultFeeDefault
|
||||
}
|
||||
if attendanceCount == 1 {
|
||||
return AdultFeeSingle
|
||||
return min(AdultFeeSingle, rate)
|
||||
}
|
||||
if rate, ok := AdultFeeMonthlyRate[monthKey]; ok {
|
||||
return rate
|
||||
}
|
||||
return AdultFeeDefault
|
||||
return rate
|
||||
}
|
||||
|
||||
@@ -26,9 +26,11 @@ func TestCalculateFee(t *testing.T) {
|
||||
// Zero attendance always returns 0.
|
||||
{"zero short-circuits", 0, "2026-05", 0},
|
||||
{"zero empty month", 0, "", 0},
|
||||
// Single practice returns AdultFeeSingle regardless of month.
|
||||
// Single practice returns AdultFeeSingle, capped at the month's rate.
|
||||
{"single practice", 1, "2026-05", AdultFeeSingle},
|
||||
{"single ignores monthKey", 1, "unknown", AdultFeeSingle},
|
||||
{"single unknown month", 1, "unknown", AdultFeeSingle},
|
||||
{"single in free month is free", 1, "2026-07", 0},
|
||||
{"two in free month is free", 2, "2026-08", 0},
|
||||
// Two+ practices for a configured month: must use the map value, not the default.
|
||||
// Expected values are read from AdultFeeMonthlyRate so this test stays correct
|
||||
// when rates are updated — the assertion verifies dispatch logic, not rate values.
|
||||
|
||||
@@ -0,0 +1,95 @@
|
||||
// Package scheduler runs a job at fixed times of day.
|
||||
package scheduler
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"log/slog"
|
||||
"sort"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
// TimeOfDay is a wall-clock time without a date.
|
||||
type TimeOfDay struct {
|
||||
Hour, Minute int
|
||||
}
|
||||
|
||||
func (t TimeOfDay) String() string { return fmt.Sprintf("%02d:%02d", t.Hour, t.Minute) }
|
||||
|
||||
// ParseTimes parses a comma-separated list of HH:MM times, e.g. "04:00" or
|
||||
// "06:00,18:00". "off" yields an empty schedule. The result is sorted and
|
||||
// de-duplicated.
|
||||
func ParseTimes(s string) ([]TimeOfDay, error) {
|
||||
s = strings.TrimSpace(s)
|
||||
if strings.EqualFold(s, "off") {
|
||||
return nil, nil
|
||||
}
|
||||
seen := map[TimeOfDay]bool{}
|
||||
var times []TimeOfDay
|
||||
for _, part := range strings.Split(s, ",") {
|
||||
part = strings.TrimSpace(part)
|
||||
parsed, err := time.Parse("15:04", part)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("invalid time %q: want HH:MM, a comma-separated list of them, or \"off\"", part)
|
||||
}
|
||||
t := TimeOfDay{Hour: parsed.Hour(), Minute: parsed.Minute()}
|
||||
if !seen[t] {
|
||||
seen[t] = true
|
||||
times = append(times, t)
|
||||
}
|
||||
}
|
||||
sort.Slice(times, func(i, j int) bool {
|
||||
if times[i].Hour != times[j].Hour {
|
||||
return times[i].Hour < times[j].Hour
|
||||
}
|
||||
return times[i].Minute < times[j].Minute
|
||||
})
|
||||
return times, nil
|
||||
}
|
||||
|
||||
// Next returns the earliest scheduled instant strictly after now, with the
|
||||
// times read in loc. It returns the zero time when times is empty.
|
||||
func Next(now time.Time, times []TimeOfDay, loc *time.Location) time.Time {
|
||||
local := now.In(loc)
|
||||
var best time.Time
|
||||
for dayOffset := 0; dayOffset <= 1; dayOffset++ {
|
||||
for _, t := range times {
|
||||
c := time.Date(local.Year(), local.Month(), local.Day()+dayOffset, t.Hour, t.Minute, 0, 0, loc)
|
||||
if c.After(now) && (best.IsZero() || c.Before(best)) {
|
||||
best = c
|
||||
}
|
||||
}
|
||||
}
|
||||
return best
|
||||
}
|
||||
|
||||
// pollInterval bounds each wait so the loop follows the wall clock across
|
||||
// clock adjustments and host suspend instead of relying on one long timer.
|
||||
const pollInterval = time.Minute
|
||||
|
||||
// Run calls job at every scheduled time until ctx is cancelled. Nothing runs
|
||||
// at startup. Runs do not overlap: the next time is computed after job returns.
|
||||
func Run(ctx context.Context, times []TimeOfDay, loc *time.Location, logger *slog.Logger, job func(context.Context)) {
|
||||
for {
|
||||
next := Next(time.Now(), times, loc)
|
||||
if next.IsZero() {
|
||||
return
|
||||
}
|
||||
logger.Info("next scheduled run", "at", next.Format(time.RFC3339))
|
||||
for {
|
||||
wait := time.Until(next)
|
||||
if wait <= 0 {
|
||||
break
|
||||
}
|
||||
timer := time.NewTimer(min(wait, pollInterval))
|
||||
select {
|
||||
case <-ctx.Done():
|
||||
timer.Stop()
|
||||
return
|
||||
case <-timer.C:
|
||||
}
|
||||
}
|
||||
job(ctx)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,115 @@
|
||||
package scheduler
|
||||
|
||||
import (
|
||||
"context"
|
||||
"io"
|
||||
"log/slog"
|
||||
"reflect"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
func TestParseTimes(t *testing.T) {
|
||||
cases := []struct {
|
||||
in string
|
||||
want []TimeOfDay
|
||||
wantErr bool
|
||||
}{
|
||||
{"04:00", []TimeOfDay{{4, 0}}, false},
|
||||
{" 18:30 , 06:00,06:00 ", []TimeOfDay{{6, 0}, {18, 30}}, false},
|
||||
{"off", nil, false},
|
||||
{"OFF", nil, false},
|
||||
{"", nil, true},
|
||||
{"25:00", nil, true},
|
||||
{"04:60", nil, true},
|
||||
{"daily", nil, true},
|
||||
{"04:00,", nil, true},
|
||||
}
|
||||
for _, tc := range cases {
|
||||
got, err := ParseTimes(tc.in)
|
||||
if (err != nil) != tc.wantErr {
|
||||
t.Errorf("ParseTimes(%q): err = %v, wantErr %v", tc.in, err, tc.wantErr)
|
||||
continue
|
||||
}
|
||||
if !reflect.DeepEqual(got, tc.want) {
|
||||
t.Errorf("ParseTimes(%q) = %v, want %v", tc.in, got, tc.want)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestNext(t *testing.T) {
|
||||
prague, err := time.LoadLocation("Europe/Prague")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
at := func(s string) time.Time {
|
||||
v, err := time.ParseInLocation("2006-01-02 15:04:05", s, prague)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return v
|
||||
}
|
||||
four := []TimeOfDay{{4, 0}}
|
||||
cases := []struct {
|
||||
name string
|
||||
now time.Time
|
||||
times []TimeOfDay
|
||||
want time.Time
|
||||
}{
|
||||
{"before today's time", at("2026-10-08 03:59:59"), four, at("2026-10-08 04:00:00")},
|
||||
{"exactly at the time moves to tomorrow", at("2026-10-08 04:00:00"), four, at("2026-10-09 04:00:00")},
|
||||
{"after today's time", at("2026-10-08 12:00:00"), four, at("2026-10-09 04:00:00")},
|
||||
{"picks the next of several", at("2026-10-08 12:00:00"), []TimeOfDay{{6, 0}, {18, 0}}, at("2026-10-08 18:00:00")},
|
||||
{"year rollover", at("2026-12-31 23:00:00"), four, at("2027-01-01 04:00:00")},
|
||||
{"now given in UTC", at("2026-10-08 03:00:00").UTC(), four, at("2026-10-08 04:00:00")},
|
||||
// Spring forward (2026-03-29 02:00 → 03:00): still 04:00 local, 23h after the previous run.
|
||||
{"spring forward", at("2026-03-28 04:00:00"), four, at("2026-03-29 04:00:00")},
|
||||
// Fall back (2026-10-25 03:00 → 02:00): still 04:00 local, 25h after the previous run.
|
||||
{"fall back", at("2026-10-24 04:00:00"), four, at("2026-10-25 04:00:00")},
|
||||
}
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
got := Next(tc.now, tc.times, prague)
|
||||
if !got.Equal(tc.want) {
|
||||
t.Errorf("Next = %s, want %s", got, tc.want)
|
||||
}
|
||||
})
|
||||
}
|
||||
if got := Next(at("2026-10-08 12:00:00"), nil, prague); !got.IsZero() {
|
||||
t.Errorf("Next with empty schedule = %s, want zero", got)
|
||||
}
|
||||
if d := at("2026-03-29 04:00:00").Sub(at("2026-03-28 04:00:00")); d != 23*time.Hour {
|
||||
t.Errorf("spring-forward gap = %s, want 23h", d)
|
||||
}
|
||||
}
|
||||
|
||||
func TestRunStopsOnCancelAndEmptySchedule(t *testing.T) {
|
||||
logger := slog.New(slog.NewTextHandler(io.Discard, nil))
|
||||
called := false
|
||||
job := func(context.Context) { called = true }
|
||||
|
||||
done := make(chan struct{})
|
||||
go func() { Run(context.Background(), nil, time.UTC, logger, job); close(done) }()
|
||||
select {
|
||||
case <-done:
|
||||
case <-time.After(2 * time.Second):
|
||||
t.Fatal("Run with empty schedule did not return")
|
||||
}
|
||||
|
||||
ctx, cancel := context.WithCancel(context.Background())
|
||||
done = make(chan struct{})
|
||||
far := time.Now().UTC().Add(12 * time.Hour)
|
||||
go func() {
|
||||
Run(ctx, []TimeOfDay{{far.Hour(), far.Minute()}}, time.UTC, logger, job)
|
||||
close(done)
|
||||
}()
|
||||
cancel()
|
||||
select {
|
||||
case <-done:
|
||||
case <-time.After(2 * time.Second):
|
||||
t.Fatal("Run did not return after cancel")
|
||||
}
|
||||
if called {
|
||||
t.Error("job must not run before its scheduled time")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,63 @@
|
||||
package banksync
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"io"
|
||||
"sync"
|
||||
"time"
|
||||
)
|
||||
|
||||
// ErrBusy is returned by Runner.Run when another run is still in progress.
|
||||
var ErrBusy = errors.New("a sync is already running")
|
||||
|
||||
// RunStatus describes one finished run of a Runner.
|
||||
type RunStatus struct {
|
||||
Started, Finished time.Time
|
||||
Trigger string // "manual" or "scheduled"
|
||||
Err error
|
||||
}
|
||||
|
||||
// Runner serialises bank sync runs so a scheduled run and a manual one never
|
||||
// overlap (overlapping runs could append the same rows twice), and remembers
|
||||
// the outcome of the last run for display.
|
||||
type Runner struct {
|
||||
job func(ctx context.Context, out io.Writer) error
|
||||
|
||||
running sync.Mutex
|
||||
|
||||
mu sync.Mutex
|
||||
last RunStatus
|
||||
hasLast bool
|
||||
}
|
||||
|
||||
// NewRunner wraps job, which performs one full sync and writes a
|
||||
// human-readable log to out.
|
||||
func NewRunner(job func(ctx context.Context, out io.Writer) error) *Runner {
|
||||
return &Runner{job: job}
|
||||
}
|
||||
|
||||
// Run executes the job unless one is already running, in which case it
|
||||
// returns ErrBusy without waiting.
|
||||
func (r *Runner) Run(ctx context.Context, trigger string, out io.Writer) error {
|
||||
if !r.running.TryLock() {
|
||||
return ErrBusy
|
||||
}
|
||||
defer r.running.Unlock()
|
||||
|
||||
st := RunStatus{Started: time.Now(), Trigger: trigger}
|
||||
st.Err = r.job(ctx, out)
|
||||
st.Finished = time.Now()
|
||||
|
||||
r.mu.Lock()
|
||||
r.last, r.hasLast = st, true
|
||||
r.mu.Unlock()
|
||||
return st.Err
|
||||
}
|
||||
|
||||
// Last returns the outcome of the most recent finished run, if any.
|
||||
func (r *Runner) Last() (RunStatus, bool) {
|
||||
r.mu.Lock()
|
||||
defer r.mu.Unlock()
|
||||
return r.last, r.hasLast
|
||||
}
|
||||
@@ -0,0 +1,65 @@
|
||||
package banksync
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"io"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestRunner_RecordsStatus(t *testing.T) {
|
||||
r := NewRunner(func(context.Context, io.Writer) error { return nil })
|
||||
if _, ok := r.Last(); ok {
|
||||
t.Fatal("Last before any run: want ok=false")
|
||||
}
|
||||
if err := r.Run(context.Background(), "scheduled", io.Discard); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
st, ok := r.Last()
|
||||
if !ok || st.Trigger != "scheduled" || st.Err != nil || st.Finished.Before(st.Started) {
|
||||
t.Errorf("unexpected status %+v ok=%v", st, ok)
|
||||
}
|
||||
}
|
||||
|
||||
func TestRunner_RecordsError(t *testing.T) {
|
||||
boom := errors.New("boom")
|
||||
r := NewRunner(func(context.Context, io.Writer) error { return boom })
|
||||
if err := r.Run(context.Background(), "manual", io.Discard); !errors.Is(err, boom) {
|
||||
t.Fatalf("Run err = %v, want boom", err)
|
||||
}
|
||||
if st, _ := r.Last(); !errors.Is(st.Err, boom) || st.Trigger != "manual" {
|
||||
t.Errorf("unexpected status %+v", st)
|
||||
}
|
||||
}
|
||||
|
||||
func TestRunner_BusyWhileRunning(t *testing.T) {
|
||||
started := make(chan struct{})
|
||||
release := make(chan struct{})
|
||||
first := true
|
||||
r := NewRunner(func(context.Context, io.Writer) error {
|
||||
if first { // runs are serialised by Runner, so no extra locking is needed
|
||||
first = false
|
||||
close(started)
|
||||
<-release
|
||||
}
|
||||
return nil
|
||||
})
|
||||
done := make(chan error, 1)
|
||||
go func() { done <- r.Run(context.Background(), "scheduled", io.Discard) }()
|
||||
<-started
|
||||
|
||||
if err := r.Run(context.Background(), "manual", io.Discard); !errors.Is(err, ErrBusy) {
|
||||
t.Errorf("second Run err = %v, want ErrBusy", err)
|
||||
}
|
||||
close(release)
|
||||
if err := <-done; err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
// The skipped run must not overwrite the status of the real one.
|
||||
if st, _ := r.Last(); st.Trigger != "scheduled" {
|
||||
t.Errorf("Last trigger = %q, want scheduled", st.Trigger)
|
||||
}
|
||||
if err := r.Run(context.Background(), "manual", io.Discard); err != nil {
|
||||
t.Errorf("Run after release: %v", err)
|
||||
}
|
||||
}
|
||||
@@ -36,6 +36,18 @@ type SyncOpts struct {
|
||||
PrintFioTable bool // with DryRun: print every fetched Fio txn with NEW/DUP status
|
||||
}
|
||||
|
||||
// DefaultWindow is the window used by the dashboard sync: the whole current
|
||||
// calendar year plus the last two months of the previous one, so payments
|
||||
// dated around New Year are still picked up in January. Re-fetching is safe
|
||||
// because rows are deduplicated by Sync ID.
|
||||
// Mirrors default_sync_window in legacy/scripts/sync_fio_to_sheets.py.
|
||||
func DefaultWindow(now time.Time) (from, to time.Time) {
|
||||
yr := now.Year()
|
||||
from = time.Date(yr-1, time.November, 1, 0, 0, 0, 0, time.UTC)
|
||||
to = time.Date(yr, time.December, 31, 23, 59, 59, 0, time.UTC)
|
||||
return from, to
|
||||
}
|
||||
|
||||
// SyncToSheets fetches Fio transactions from all provided clients and appends
|
||||
// new ones to the payments sheet. Returns the number of rows appended.
|
||||
// Ports legacy/scripts/sync_fio_to_sheets.py sync_to_sheets.
|
||||
|
||||
@@ -193,3 +193,23 @@ func syncIDFor(tx fio.Transaction) string {
|
||||
Sender: tx.Sender, VS: tx.VS, Message: tx.Message, BankID: tx.BankID,
|
||||
})
|
||||
}
|
||||
|
||||
func TestDefaultWindow(t *testing.T) {
|
||||
cases := []struct {
|
||||
now time.Time
|
||||
from, to string
|
||||
}{
|
||||
{time.Date(2026, 10, 8, 12, 0, 0, 0, time.UTC), "2025-11-01", "2026-12-31"},
|
||||
{time.Date(2027, 1, 1, 0, 0, 0, 0, time.UTC), "2026-11-01", "2027-12-31"},
|
||||
{time.Date(2027, 12, 31, 23, 0, 0, 0, time.UTC), "2026-11-01", "2027-12-31"},
|
||||
}
|
||||
for _, tc := range cases {
|
||||
from, to := DefaultWindow(tc.now)
|
||||
if got := from.Format("2006-01-02"); got != tc.from {
|
||||
t.Errorf("DefaultWindow(%s) from: want %s, got %s", tc.now.Format("2006-01-02"), tc.from, got)
|
||||
}
|
||||
if got := to.Format("2006-01-02"); got != tc.to {
|
||||
t.Errorf("DefaultWindow(%s) to: want %s, got %s", tc.now.Format("2006-01-02"), tc.to, got)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -21,17 +21,26 @@ func NewHTMLHandler(r *Renderer, b BuildInfo, ah *api.Handler, actions ActionHan
|
||||
return &HTMLHandler{renderer: r, build: b, apiHandler: ah, actions: actions}
|
||||
}
|
||||
|
||||
// page builds the data shared by every page (nav highlight, build info, sync summary).
|
||||
func (h *HTMLHandler) page(active string) PageData {
|
||||
pd := PageData{Active: active, Build: h.build}
|
||||
if h.actions.SyncInfo != nil {
|
||||
pd.SyncInfo = h.actions.SyncInfo()
|
||||
}
|
||||
return pd
|
||||
}
|
||||
|
||||
func (h *HTMLHandler) ServeAdults(w http.ResponseWriter, r *http.Request) {
|
||||
data, err := h.apiHandler.AssembleAdults(r.Context())
|
||||
if err != nil {
|
||||
h.renderer.Render(w, "adults", AdultsPageData{
|
||||
PageData: PageData{Active: "adults", Build: h.build},
|
||||
PageData: h.page("adults"),
|
||||
Error: err.Error(),
|
||||
})
|
||||
return
|
||||
}
|
||||
h.renderer.Render(w, "adults", AdultsPageData{
|
||||
PageData: PageData{Active: "adults", Build: h.build},
|
||||
PageData: h.page("adults"),
|
||||
Data: data,
|
||||
})
|
||||
}
|
||||
@@ -40,13 +49,13 @@ func (h *HTMLHandler) ServeJuniors(w http.ResponseWriter, r *http.Request) {
|
||||
data, err := h.apiHandler.AssembleJuniors(r.Context())
|
||||
if err != nil {
|
||||
h.renderer.Render(w, "juniors", JuniorsPageData{
|
||||
PageData: PageData{Active: "juniors", Build: h.build},
|
||||
PageData: h.page("juniors"),
|
||||
Error: err.Error(),
|
||||
})
|
||||
return
|
||||
}
|
||||
h.renderer.Render(w, "juniors", JuniorsPageData{
|
||||
PageData: PageData{Active: "juniors", Build: h.build},
|
||||
PageData: h.page("juniors"),
|
||||
Data: data,
|
||||
})
|
||||
}
|
||||
@@ -55,20 +64,20 @@ func (h *HTMLHandler) ServePayments(w http.ResponseWriter, r *http.Request) {
|
||||
data, err := h.apiHandler.AssemblePayments(r.Context())
|
||||
if err != nil {
|
||||
h.renderer.Render(w, "payments", PaymentsPageData{
|
||||
PageData: PageData{Active: "payments", Build: h.build},
|
||||
PageData: h.page("payments"),
|
||||
Error: err.Error(),
|
||||
})
|
||||
return
|
||||
}
|
||||
h.renderer.Render(w, "payments", PaymentsPageData{
|
||||
PageData: PageData{Active: "payments", Build: h.build},
|
||||
PageData: h.page("payments"),
|
||||
Data: data,
|
||||
})
|
||||
}
|
||||
|
||||
// ServeSync handles GET /sync-bank: runs sync+infer+flush then renders the result.
|
||||
func (h *HTMLHandler) ServeSync(w http.ResponseWriter, r *http.Request) {
|
||||
pd := PageData{Active: "sync", Build: h.build}
|
||||
pd := h.page("sync")
|
||||
|
||||
if h.actions.BankSync == nil {
|
||||
h.renderer.Render(w, "sync", SyncPageData{
|
||||
@@ -96,7 +105,7 @@ func (h *HTMLHandler) ServeSync(w http.ResponseWriter, r *http.Request) {
|
||||
}
|
||||
|
||||
h.renderer.Render(w, "sync", SyncPageData{
|
||||
PageData: pd,
|
||||
PageData: h.page("sync"), // rebuilt so the footer reflects this run
|
||||
Output: buf.String(),
|
||||
Success: success,
|
||||
})
|
||||
@@ -105,7 +114,7 @@ func (h *HTMLHandler) ServeSync(w http.ResponseWriter, r *http.Request) {
|
||||
// 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},
|
||||
PageData: h.page("flush"),
|
||||
})
|
||||
}
|
||||
|
||||
@@ -113,7 +122,7 @@ func (h *HTMLHandler) ServeFlushCacheGET(w http.ResponseWriter, r *http.Request)
|
||||
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},
|
||||
PageData: h.page("flush"),
|
||||
Flushed: true,
|
||||
Deleted: n,
|
||||
})
|
||||
|
||||
@@ -314,6 +314,28 @@ func TestServeSync(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
func TestFooterSyncInfo(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"}
|
||||
get := func(actions web.ActionHandlers) string {
|
||||
h := web.NewHTMLHandler(renderer, b, fixtureHandler(t), actions)
|
||||
w := httptest.NewRecorder()
|
||||
h.ServeFlushCacheGET(w, httptest.NewRequest(http.MethodGet, "/flush-cache", nil))
|
||||
return w.Body.String()
|
||||
}
|
||||
|
||||
const info = "last sync 2026-10-08 04:00 (scheduled) ok"
|
||||
if body := get(web.ActionHandlers{SyncInfo: func() string { return info }}); !strings.Contains(body, "| "+info) {
|
||||
t.Errorf("footer missing sync info %q", info)
|
||||
}
|
||||
if body := get(web.ActionHandlers{}); strings.Contains(body, "last sync") {
|
||||
t.Errorf("footer shows sync info although none was provided")
|
||||
}
|
||||
}
|
||||
|
||||
func TestPaymentQRMarkup(t *testing.T) {
|
||||
renderer, err := web.NewRenderer()
|
||||
if err != nil {
|
||||
|
||||
@@ -10,8 +10,9 @@ import (
|
||||
|
||||
// PageData is the view model passed to every HTML template.
|
||||
type PageData struct {
|
||||
Active string
|
||||
Build BuildInfo
|
||||
Active string
|
||||
Build BuildInfo
|
||||
SyncInfo string // last/next bank sync summary shown in the footer; empty hides it
|
||||
}
|
||||
|
||||
// AdultsPageData is the view model for the /adults HTML page.
|
||||
|
||||
@@ -26,6 +26,9 @@ 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
|
||||
// SyncInfo returns a one-line summary of the last and next bank sync for
|
||||
// the page footer. nil or an empty result shows nothing.
|
||||
SyncInfo func() string
|
||||
}
|
||||
|
||||
// Run registers routes and starts the HTTP server on addr.
|
||||
|
||||
@@ -1,3 +1,3 @@
|
||||
{{define "footer"}}
|
||||
<div class="footer">{{.Build.Version}}@{{.Build.Commit}} | built {{.Build.BuildDate}}</div>
|
||||
<div class="footer">{{.Build.Version}}@{{.Build.Commit}} | built {{.Build.BuildDate}}{{if .SyncInfo}} | {{.SyncInfo}}{{end}}</div>
|
||||
{{end}}
|
||||
|
||||
@@ -9,7 +9,7 @@
|
||||
{{end}}
|
||||
<pre class="sync-log{{if not .Success}} sync-log--error{{end}}">{{.Output}}</pre>
|
||||
{{else}}
|
||||
<p class="description">Fetches Fio transactions for the current year, infers payment details, and flushes the cache.</p>
|
||||
<p class="description">Fetches Fio transactions for the current year and the last two months of the previous one, infers payment details, and flushes the cache.</p>
|
||||
{{end}}
|
||||
<p><a href="/sync-bank" class="btn">{{if .Output}}Run Again{{else}}Run Sync{{end}}</a></p>
|
||||
{{end}}
|
||||
|
||||
@@ -0,0 +1,12 @@
|
||||
{
|
||||
"case": "one_session_free_july",
|
||||
"func": "scripts.attendance.calculate_fee",
|
||||
"captured_at": "2026-10-08",
|
||||
"input": {
|
||||
"attendance_count": 1,
|
||||
"month_key": "2026-07"
|
||||
},
|
||||
"output": {
|
||||
"fee": 0
|
||||
}
|
||||
}
|
||||
@@ -1,12 +1,12 @@
|
||||
{
|
||||
"case": "two_sessions_default_fallback",
|
||||
"func": "scripts.attendance.calculate_fee",
|
||||
"captured_at": "2026-05-06",
|
||||
"captured_at": "2026-10-08",
|
||||
"input": {
|
||||
"attendance_count": 2,
|
||||
"month_key": "2099-01"
|
||||
},
|
||||
"output": {
|
||||
"fee": 700
|
||||
"fee": 600
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,12 @@
|
||||
{
|
||||
"case": "two_sessions_free_july",
|
||||
"func": "scripts.attendance.calculate_fee",
|
||||
"captured_at": "2026-10-08",
|
||||
"input": {
|
||||
"attendance_count": 2,
|
||||
"month_key": "2026-07"
|
||||
},
|
||||
"output": {
|
||||
"fee": 0
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,12 @@
|
||||
{
|
||||
"case": "two_sessions_october",
|
||||
"func": "scripts.attendance.calculate_fee",
|
||||
"captured_at": "2026-10-08",
|
||||
"input": {
|
||||
"attendance_count": 2,
|
||||
"month_key": "2026-10"
|
||||
},
|
||||
"output": {
|
||||
"fee": 600
|
||||
}
|
||||
}
|
||||
+8
-5
@@ -30,7 +30,7 @@ from views import (
|
||||
adapt_junior_members,
|
||||
)
|
||||
from cache_utils import get_sheet_modified_time, read_cache, write_cache, _LAST_CHECKED, flush_cache
|
||||
from sync_fio_to_sheets import sync_to_sheets
|
||||
from sync_fio_to_sheets import sync_to_sheets, default_sync_window
|
||||
from infer_payments import infer_payments
|
||||
|
||||
def get_cached_data(cache_key, sheet_id, fetch_func, *args, serialize=None, deserialize=None, **kwargs):
|
||||
@@ -121,6 +121,8 @@ def flush_cache_endpoint():
|
||||
deleted = flush_cache()
|
||||
return render_template("flush-cache.html", flushed=True, deleted=deleted)
|
||||
|
||||
# Scheduled (daily) bank sync exists only in the Go server, on purpose: this
|
||||
# app is legacy and being phased out. Here the sync runs only on request.
|
||||
@app.route("/sync-bank")
|
||||
def sync_bank():
|
||||
import contextlib
|
||||
@@ -128,13 +130,14 @@ def sync_bank():
|
||||
success = True
|
||||
try:
|
||||
with contextlib.redirect_stdout(output), contextlib.redirect_stderr(output):
|
||||
# sync_to_sheets: equivalent of make sync-2026
|
||||
output.write("=== Syncing Fio transactions (2026) ===\n")
|
||||
# sync_to_sheets: equivalent of make sync-year (same default window as Go)
|
||||
date_from, date_to = default_sync_window()
|
||||
output.write(f"=== Syncing Fio transactions ({date_from} to {date_to}) ===\n")
|
||||
sync_to_sheets(
|
||||
spreadsheet_id=PAYMENTS_SHEET_ID,
|
||||
credentials_path=CREDENTIALS_PATH,
|
||||
date_from_str="2026-01-01",
|
||||
date_to_str="2026-12-31",
|
||||
date_from_str=date_from,
|
||||
date_to_str=date_to,
|
||||
sort_by_date=True,
|
||||
)
|
||||
output.write("\n=== Inferring payment details ===\n")
|
||||
|
||||
@@ -115,6 +115,15 @@ SEEDS[("calculate_fee", "two_sessions_reduced_march")] = {
|
||||
SEEDS[("calculate_fee", "two_sessions_default_fallback")] = {
|
||||
"attendance_count": 2, "month_key": "2099-01"
|
||||
}
|
||||
SEEDS[("calculate_fee", "two_sessions_free_july")] = {
|
||||
"attendance_count": 2, "month_key": "2026-07"
|
||||
}
|
||||
SEEDS[("calculate_fee", "one_session_free_july")] = {
|
||||
"attendance_count": 1, "month_key": "2026-07"
|
||||
}
|
||||
SEEDS[("calculate_fee", "two_sessions_october")] = {
|
||||
"attendance_count": 2, "month_key": "2026-10"
|
||||
}
|
||||
|
||||
|
||||
# --- calculate_junior_fee ---
|
||||
|
||||
@@ -10,7 +10,7 @@ from config import ATTENDANCE_SHEET_ID as SHEET_ID, JUNIOR_SHEET_GID
|
||||
EXPORT_URL = f"https://docs.google.com/spreadsheets/d/{SHEET_ID}/export?format=csv&gid=0"
|
||||
JUNIOR_EXPORT_URL = f"https://docs.google.com/spreadsheets/d/{SHEET_ID}/export?format=csv&gid={JUNIOR_SHEET_GID}"
|
||||
|
||||
ADULT_FEE_DEFAULT = 700 # CZK, for 2+ practices in a month
|
||||
ADULT_FEE_DEFAULT = 600 # CZK, for 2+ practices in a month
|
||||
ADULT_FEE_SINGLE = 200 # CZK, for exactly 1 practice in a month
|
||||
ADULT_FEE_MONTHLY_RATE = {
|
||||
"2025-09": 750,
|
||||
@@ -23,8 +23,12 @@ ADULT_FEE_MONTHLY_RATE = {
|
||||
"2026-04": 700,
|
||||
"2026-05": 450,
|
||||
"2026-06": 600,
|
||||
"2026-07": 600,
|
||||
"2026-08": 600,
|
||||
"2026-07": 0,
|
||||
"2026-08": 0,
|
||||
"2026-09": 600,
|
||||
"2026-10": 600,
|
||||
"2026-11": 600,
|
||||
"2026-12": 600,
|
||||
}
|
||||
|
||||
JUNIOR_FEE_DEFAULT = 500 # CZK for 2+ practices
|
||||
@@ -91,12 +95,13 @@ def group_by_month(dates: list[tuple[int, datetime]], merged_months: dict[str, s
|
||||
|
||||
|
||||
def calculate_fee(attendance_count: int, month_key: str) -> int:
|
||||
"""Apply fee rules: 0 → 0, 1 → 200, 2+ → configured rate (default 750)."""
|
||||
"""Apply fee rules: 0 → 0, 1 → 200 (capped at the month's rate), 2+ → configured rate (default 600)."""
|
||||
if attendance_count == 0:
|
||||
return 0
|
||||
rate = ADULT_FEE_MONTHLY_RATE.get(month_key, ADULT_FEE_DEFAULT)
|
||||
if attendance_count == 1:
|
||||
return ADULT_FEE_SINGLE
|
||||
return ADULT_FEE_MONTHLY_RATE.get(month_key, ADULT_FEE_DEFAULT)
|
||||
return min(ADULT_FEE_SINGLE, rate)
|
||||
return rate
|
||||
|
||||
|
||||
def calculate_junior_fee(attendance_count: int, month_key: str) -> str | int:
|
||||
|
||||
@@ -59,6 +59,18 @@ def get_sheets_service(credentials_path: str):
|
||||
return _SHEETS_SERVICE
|
||||
|
||||
|
||||
def default_sync_window(today=None) -> tuple[str, str]:
|
||||
"""Window used by the dashboard sync, as (from, to) in YYYY-MM-DD.
|
||||
|
||||
The whole current calendar year plus the last two months of the previous
|
||||
one, so payments dated around New Year are still picked up in January.
|
||||
Re-fetching is safe because rows are deduplicated by Sync ID.
|
||||
Mirrors DefaultWindow in go/internal/services/banksync/sync.go.
|
||||
"""
|
||||
year = (today or datetime.now()).year
|
||||
return f"{year - 1}-11-01", f"{year}-12-31"
|
||||
|
||||
|
||||
def as_text_cell(value) -> str:
|
||||
"""Mark a value to be stored as text when written with USER_ENTERED.
|
||||
|
||||
|
||||
@@ -23,6 +23,20 @@ class TestWebApp(unittest.TestCase):
|
||||
app.config['TESTING'] = True
|
||||
self.client = app.test_client()
|
||||
|
||||
@patch('app.flush_cache', return_value=0)
|
||||
@patch('app.infer_payments')
|
||||
@patch('app.sync_to_sheets')
|
||||
def test_sync_bank_uses_default_window(self, mock_sync, mock_infer, mock_flush):
|
||||
"""/sync-bank syncs the current year plus Nov-Dec of the previous one, not a hardcoded year."""
|
||||
from datetime import datetime
|
||||
year = datetime.now().year
|
||||
response = self.client.get('/sync-bank')
|
||||
self.assertEqual(response.status_code, 200)
|
||||
kwargs = mock_sync.call_args.kwargs
|
||||
self.assertEqual(kwargs['date_from_str'], f"{year - 1}-11-01")
|
||||
self.assertEqual(kwargs['date_to_str'], f"{year}-12-31")
|
||||
mock_infer.assert_called_once()
|
||||
|
||||
def test_index_page(self):
|
||||
"""Test that / returns the refresh meta tag"""
|
||||
response = self.client.get('/')
|
||||
|
||||
@@ -1,9 +1,17 @@
|
||||
import contextlib
|
||||
import io
|
||||
import unittest
|
||||
from datetime import datetime
|
||||
from unittest.mock import MagicMock, patch
|
||||
|
||||
from scripts.sync_fio_to_sheets import COLUMN_LABELS, as_text_cell, sync_to_sheets
|
||||
from scripts.sync_fio_to_sheets import COLUMN_LABELS, as_text_cell, default_sync_window, sync_to_sheets
|
||||
|
||||
|
||||
class TestDefaultSyncWindow(unittest.TestCase):
|
||||
def test_current_year_plus_last_two_months_of_previous(self):
|
||||
self.assertEqual(default_sync_window(datetime(2026, 10, 8)), ("2025-11-01", "2026-12-31"))
|
||||
self.assertEqual(default_sync_window(datetime(2027, 1, 1)), ("2026-11-01", "2027-12-31"))
|
||||
self.assertEqual(default_sync_window(datetime(2027, 12, 31)), ("2026-11-01", "2027-12-31"))
|
||||
|
||||
|
||||
class TestAsTextCell(unittest.TestCase):
|
||||
|
||||
Reference in New Issue
Block a user