diff --git a/.claude/launch.json b/.claude/launch.json index afabfdb..ff56067 100644 --- a/.claude/launch.json +++ b/.claude/launch.json @@ -17,6 +17,24 @@ "port": 5173, "autoPort": false }, + { + "name": "api-server-8081", + "runtimeExecutable": "./bin/api-server.exe", + "runtimeArgs": [], + "cwd": "API Server", + "env": { "API_ADDR": ":8081" }, + "port": 8081, + "autoPort": false + }, + { + "name": "web-app-8081", + "runtimeExecutable": "npm", + "runtimeArgs": ["run", "dev"], + "cwd": "Web App/web", + "env": { "VITE_API_TARGET": "http://localhost:8081" }, + "port": 5173, + "autoPort": false + }, { "name": "web-bff", "runtimeExecutable": "go", diff --git a/API Server/internal/api/chargingtasks_run.go b/API Server/internal/api/chargingtasks_run.go index 2321504..dbabd11 100644 --- a/API Server/internal/api/chargingtasks_run.go +++ b/API Server/internal/api/chargingtasks_run.go @@ -62,6 +62,8 @@ type taskRunResult struct { func (s *Server) StartScheduler() { ctx, cancel := context.WithCancel(context.Background()) s.schedulerStop = cancel + // Automatic odometer updates ride on the same lifetime (odometersync.go). + s.startOdometerSync(ctx) go func() { t := time.NewTicker(taskTick) defer t.Stop() diff --git a/API Server/internal/api/odometersync.go b/API Server/internal/api/odometersync.go new file mode 100644 index 0000000..4bc2b0d --- /dev/null +++ b/API Server/internal/api/odometersync.go @@ -0,0 +1,237 @@ +package api + +// Automatic odometer updates from a car's connected service. +// +// The MyToyota tab already offers the provider's odometer when it is ahead of +// the stored one; this is that same write done on a timer, so a car that is +// driven every day does not need somebody to open its page and press the +// button. It runs on the server's own ticker rather than in the browser for the +// same reason the charging scheduler does: an update that needs the page open +// is a reminder, not an update. +// +// Provider calls always run under a person's account, so the car remembers who +// switched updates on and reads under theirs. That person must still have write +// access when a sweep comes round — a share that was revoked stops the updates +// rather than letting them write on a car the user no longer may edit. + +import ( + "context" + "encoding/json" + "errors" + "log" + "net/http" + "net/url" + "time" +) + +// The intervals offered, in minutes. A fixed set rather than any number: the +// provider's servers are somebody else's, and every update is a login plus a +// batch of calls, so nothing more often than every half hour. +var odometerSyncIntervals = map[int]bool{ + 30: true, 60: true, 180: true, 360: true, 720: true, 1440: true, 10080: true, +} + +// defaultOdometerSyncMinutes is what a car gets when updates are switched on +// without an interval: once a day, enough for service reminders. +const defaultOdometerSyncMinutes = 1440 + +// How often the sweep looks for cars that are due. The shortest interval is 30 +// minutes, so a five-minute look lands every update within five of its time. +const odometerSyncTick = 5 * time.Minute + +// How long one sweep may take, across every due car. +const odometerSyncSweepTimeout = 4 * time.Minute + +// PUT /api/cars/{id}/provider/auto-sync — switch automatic odometer updates on +// or off, and choose how often. Body: {enabled: bool, intervalMinutes?: int}. +// Needs write access, since the updates write to the car, and a linked car. +// Switching on records the caller as the account the readings come from, and +// runs one update straight away so the choice shows its effect. +func (s *Server) handleCarOdometerAutoSync(w http.ResponseWriter, r *http.Request) { + who := caller(r) + if who == nil { + writeError(w, http.StatusUnauthorized, "not authenticated") + return + } + var body struct { + Enabled bool `json:"enabled"` + IntervalMinutes int `json:"intervalMinutes"` + } + if err := decodeJSON(r, &body); err != nil { + writeError(w, http.StatusBadRequest, err.Error()) + return + } + carID := r.PathValue("id") + level, rec, err := s.carAccessLevel(r.Context(), who.ID, carID) + if err != nil { + writePBError(w, err) + return + } + if !canWrite(level) { + writeError(w, http.StatusForbidden, "you cannot edit this car") + return + } + if rec.Provider == "" { + writeError(w, http.StatusBadRequest, "this car is not linked to a connected service") + return + } + + minutes := body.IntervalMinutes + if minutes == 0 { + minutes = rec.OdometerSyncMinutes + } + if minutes == 0 { + minutes = defaultOdometerSyncMinutes + } + if !odometerSyncIntervals[minutes] { + writeError(w, http.StatusBadRequest, "unsupported interval") + return + } + + payload := map[string]any{ + "odometer_auto_sync": body.Enabled, + "odometer_sync_minutes": minutes, + } + if body.Enabled { + payload["odometer_sync_by"] = who.ID + } else { + payload["odometer_sync_error"] = "" + } + var updated carRecord + if err := s.pb.Update(r.Context(), colCars, carID, payload, &updated); err != nil { + writePBError(w, err) + return + } + // Switching on (or changing the interval while on) updates once now, so the + // panel can show "last checked" and the odometer moves without waiting a day. + if body.Enabled { + s.syncCarOdometer(r.Context(), updated) + _ = s.pb.GetOne(r.Context(), colCars, carID, &updated) + } + m := updated.toModel() + m.Access = level + writeJSON(w, http.StatusOK, m) +} + +// startOdometerSync starts the ticker that updates due cars. Called from +// StartScheduler and stopped by the same cancel. +func (s *Server) startOdometerSync(ctx context.Context) { + go func() { + t := time.NewTicker(odometerSyncTick) + defer t.Stop() + for { + select { + case <-ctx.Done(): + return + case <-t.C: + s.sweepOdometerSync(ctx) + } + } + }() +} + +// sweepOdometerSync updates every car whose interval has run out. +func (s *Server) sweepOdometerSync(ctx context.Context) { + if !s.pb.Configured() { + return + } + ctx, cancel := context.WithTimeout(ctx, odometerSyncSweepTimeout) + defer cancel() + + res, err := s.pb.List(ctx, colCars, url.Values{ + "filter": {`odometer_auto_sync=true && provider!=""`}, + "perPage": {"500"}, + }) + if err != nil { + return // the database not answering is retried next tick, silently + } + var recs []carRecord + if err := json.Unmarshal(res.Items, &recs); err != nil { + return + } + now := time.Now() + for _, rec := range recs { + if !odometerSyncDue(rec, now) { + continue + } + s.syncCarOdometer(ctx, rec) + } +} + +// odometerSyncDue says whether a car's interval has run out. A car never +// attempted, or whose timestamp is unreadable, is due. +func odometerSyncDue(rec carRecord, now time.Time) bool { + minutes := rec.OdometerSyncMinutes + if minutes <= 0 { + minutes = defaultOdometerSyncMinutes + } + last, err := time.Parse(time.RFC3339, rec.OdometerSyncedAt) + if err != nil { + return true + } + return !now.Before(last.Add(time.Duration(minutes) * time.Minute)) +} + +// syncCarOdometer fetches the provider's odometer for one car and stores it +// when it is ahead of the car's, then records the attempt. Failures are stored +// on the car (and so shown on its page) rather than returned: there is nobody +// waiting on a background update to tell. +func (s *Server) syncCarOdometer(ctx context.Context, rec carRecord) { + km, err := s.fetchCarOdometer(ctx, rec) + + payload := map[string]any{ + "odometer_synced_at": time.Now().UTC().Format(time.RFC3339), + "odometer_sync_error": "", + } + if err != nil { + payload["odometer_sync_error"] = err.Error() + log.Printf("odometer sync: car %s (%s): %v", rec.ID, rec.Name, err) + } else if km > rec.CurrentKm { + // Only ever forward, as with the button: a reading behind the stored one + // is the provider being stale, not the car running backwards. + payload["current_km"] = km + } + if err := s.pb.Update(ctx, colCars, rec.ID, payload, nil); err != nil { + log.Printf("odometer sync: car %s: saving: %v", rec.ID, err) + } +} + +// fetchCarOdometer reads the provider's odometer for a car under the account of +// the user who switched updates on, checking they may still write to it. +func (s *Server) fetchCarOdometer(ctx context.Context, rec carRecord) (int, error) { + if rec.OdometerSyncBy == "" { + return 0, errors.New("nobody is set to read this car's odometer; switch automatic updates off and on again") + } + level, _, err := s.carAccessLevel(ctx, rec.OdometerSyncBy, rec.ID) + if err != nil { + return 0, err + } + if !canWrite(level) { + return 0, errors.New("the user who switched automatic updates on can no longer edit this car") + } + who, userRaw, err := s.callerForUser(ctx, rec.OdometerSyncBy) + if err != nil { + return 0, err + } + src, found := carVehicleSource(rec.Provider, rec.Make) + if !found { + return 0, errors.New("unknown vehicle provider") + } + cfg, ok, detail := src.gate(ctx, s, who, userRaw) + if !ok { + return 0, errors.New(detail) + } + vehicles, err := s.fetchProviderVehicles(ctx, src, cfg) + if err != nil { + return 0, err + } + vehicle, found := findVehicle(vehicles, rec.ProviderVehicleID) + if !found { + return 0, errors.New("this vehicle is not on the " + src.label() + " account") + } + km, ok := s.providerOdometer(ctx, src, cfg, vehicle.ID) + if !ok { + return 0, errors.New(src.label() + " did not report an odometer") + } + return km, nil +} diff --git a/API Server/internal/api/odometersync_test.go b/API Server/internal/api/odometersync_test.go new file mode 100644 index 0000000..79b6c8e --- /dev/null +++ b/API Server/internal/api/odometersync_test.go @@ -0,0 +1,65 @@ +package api + +import ( + "net/http" + "strings" + "testing" + "time" +) + +func TestOdometerSyncDue(t *testing.T) { + now := time.Date(2026, 11, 18, 12, 0, 0, 0, time.UTC) + at := func(d time.Duration) string { return now.Add(-d).Format(time.RFC3339) } + + cases := []struct { + name string + rec carRecord + want bool + }{ + {"never attempted", carRecord{OdometerSyncMinutes: 60}, true}, + {"unreadable timestamp", carRecord{OdometerSyncMinutes: 60, OdometerSyncedAt: "yesterday"}, true}, + {"inside the interval", carRecord{OdometerSyncMinutes: 60, OdometerSyncedAt: at(59 * time.Minute)}, false}, + {"exactly at the interval", carRecord{OdometerSyncMinutes: 60, OdometerSyncedAt: at(time.Hour)}, true}, + {"no interval falls back to daily", carRecord{OdometerSyncedAt: at(23 * time.Hour)}, false}, + {"daily default runs out", carRecord{OdometerSyncedAt: at(24 * time.Hour)}, true}, + } + for _, c := range cases { + if got := odometerSyncDue(c.rec, now); got != c.want { + t.Errorf("%s: due = %v, want %v", c.name, got, c.want) + } + } +} + +func TestOdometerAutoSyncNeedsLinkedCar(t *testing.T) { + srv := newProviderTestServer(t, &fakeProviderPB{}) + status, body := call(t, srv, http.MethodPut, "/api/cars/"+provCarID+"/provider/auto-sync", `{"enabled":true}`) + if status != http.StatusBadRequest || !strings.Contains(toStr(body["error"]), "not linked") { + t.Errorf("status = %d (%v), want 400 not linked", status, body["error"]) + } +} + +func TestOdometerAutoSyncRejectsOddInterval(t *testing.T) { + srv := newProviderTestServer(t, &fakeProviderPB{carProvider: "toyota", carVehicleID: "VIN1"}) + status, body := call(t, srv, http.MethodPut, "/api/cars/"+provCarID+"/provider/auto-sync", + `{"enabled":true,"intervalMinutes":7}`) + if status != http.StatusBadRequest || !strings.Contains(toStr(body["error"]), "interval") { + t.Errorf("status = %d (%v), want 400 unsupported interval", status, body["error"]) + } +} + +func TestOdometerAutoSyncSwitchOff(t *testing.T) { + fake := &fakeProviderPB{carProvider: "toyota", carVehicleID: "VIN1"} + srv := newProviderTestServer(t, fake) + status, body := call(t, srv, http.MethodPut, "/api/cars/"+provCarID+"/provider/auto-sync", + `{"enabled":false,"intervalMinutes":360}`) + if status != http.StatusOK { + t.Fatalf("status = %d (%v), want 200", status, body["error"]) + } + patch := fake.patch() + if patch["odometer_auto_sync"] != false || patch["odometer_sync_minutes"] != float64(360) { + t.Errorf("patch = %+v, want updates off at 360 minutes", patch) + } + if _, set := patch["odometer_sync_by"]; set { + t.Error("switching off must not record whose account to read under") + } +} diff --git a/API Server/internal/api/records.go b/API Server/internal/api/records.go index caa352b..10923a0 100644 --- a/API Server/internal/api/records.go +++ b/API Server/internal/api/records.go @@ -64,6 +64,11 @@ type carRecord struct { FirstRegistrationDate string `json:"first_registration_date"` Provider string `json:"provider"` ProviderVehicleID string `json:"provider_vehicle_id"` + OdometerAutoSync bool `json:"odometer_auto_sync"` + OdometerSyncMinutes int `json:"odometer_sync_minutes"` + OdometerSyncBy string `json:"odometer_sync_by"` + OdometerSyncedAt string `json:"odometer_synced_at"` + OdometerSyncError string `json:"odometer_sync_error"` Owner string `json:"owner"` Created string `json:"created"` Updated string `json:"updated"` @@ -108,7 +113,11 @@ func (rec carRecord) toModel() models.Car { FirstRegistrationDate: rec.FirstRegistrationDate, Provider: rec.Provider, ProviderVehicleID: rec.ProviderVehicleID, - HiddenTabs: decodeStringList(rec.HiddenTabs), + OdometerAutoSync: rec.OdometerAutoSync, + OdometerSyncMinutes: rec.OdometerSyncMinutes, + OdometerSyncedAt: rec.OdometerSyncedAt, + OdometerSyncError: rec.OdometerSyncError, + HiddenTabs: decodeStringList(rec.HiddenTabs), HiddenFields: decodeStringList(rec.HiddenFields), HiddenServiceColumns: decodeStringList(rec.HiddenServiceColumns), HiddenServiceParts: decodeStringList(rec.HiddenServiceParts), @@ -155,6 +164,8 @@ func carPayload(c models.Car) map[string]any { // provider clears both fields (unlink). func carProviderPayload(provider, vehicleID string) map[string]any { if provider == "" { + // Automatic odometer updates are left as they are: the sweep only looks + // at linked cars, so an unlinked one is simply never updated. return map[string]any{"provider": "", "provider_vehicle_id": ""} } return map[string]any{"provider": provider, "provider_vehicle_id": vehicleID} diff --git a/API Server/internal/api/server.go b/API Server/internal/api/server.go index 757c061..a1532e5 100644 --- a/API Server/internal/api/server.go +++ b/API Server/internal/api/server.go @@ -72,6 +72,7 @@ // PUT /api/cars/{id}/view // GET /api/cars/{id}/provider POST /api/cars/{id}/provider // POST /api/cars/{id}/provider/sync +// PUT /api/cars/{id}/provider/auto-sync // GET /api/cars/{id}/service-records // GET /api/cars/{id}/parts // GET /api/cars/{id}/shares POST /api/cars/{id}/shares @@ -530,6 +531,7 @@ func (s *Server) Handler() http.Handler { mux.HandleFunc("GET /api/cars/{id}/provider", s.handleCarProvider) mux.HandleFunc("POST /api/cars/{id}/provider", s.handleLinkCarProvider) mux.HandleFunc("POST /api/cars/{id}/provider/sync", s.handleSyncCarProvider) + mux.HandleFunc("PUT /api/cars/{id}/provider/auto-sync", s.handleCarOdometerAutoSync) mux.HandleFunc("GET /api/cars/{id}/shares", s.handleListShares) mux.HandleFunc("POST /api/cars/{id}/shares", s.handleUpsertShare) mux.HandleFunc("DELETE /api/cars/{id}/shares/{userId}", s.handleDeleteShare) diff --git a/API Server/internal/bootstrap/schema.go b/API Server/internal/bootstrap/schema.go index 0b67c74..12dc7e2 100644 --- a/API Server/internal/bootstrap/schema.go +++ b/API Server/internal/bootstrap/schema.go @@ -41,6 +41,15 @@ var collectionsSchema = map[string][]fieldDef{ // internal/api/vehicleproviders.go. Blank for a hand-entered car. fText("provider", false), fText("provider_vehicle_id", false), + // Automatic odometer updates from that service: on/off, how often (in + // minutes), whose account the reading is fetched under (the user who + // switched it on — provider calls always run as a person), and the last + // attempt with its error, if any. See internal/api/odometersync.go. + fBool("odometer_auto_sync"), + fNumber("odometer_sync_minutes"), + fText("odometer_sync_by", false), + fText("odometer_synced_at", false), + fText("odometer_sync_error", false), // What this car's page shows: the tabs switched off (["fuel"] on an EV) // and the Information fields switched off (["differentialOil"] on a car // without one). Properties of the car, so everyone it is shared with sees diff --git a/API Server/internal/models/models.go b/API Server/internal/models/models.go index 28adc25..6d402e0 100644 --- a/API Server/internal/models/models.go +++ b/API Server/internal/models/models.go @@ -66,6 +66,15 @@ type Car struct { Provider string `json:"provider,omitempty"` ProviderVehicleID string `json:"providerVehicleId,omitempty"` + // OdometerAutoSync keeps CurrentKm in step with the provider's odometer in + // the background, every OdometerSyncMinutes. OdometerSyncedAt is the last + // attempt (RFC 3339) and OdometerSyncError what went wrong with it, if + // anything. Set through PUT /api/cars/{id}/provider/auto-sync only. + OdometerAutoSync bool `json:"odometerAutoSync"` + OdometerSyncMinutes int `json:"odometerSyncMinutes,omitempty"` + OdometerSyncedAt string `json:"odometerSyncedAt,omitempty"` + OdometerSyncError string `json:"odometerSyncError,omitempty"` + // HiddenTabs and HiddenFields are what this car's page does not show: tabs // (["fuel"] on an EV) and Information fields (["differentialOil"] on a car // without one). Properties of the car, so everyone it is shared with sees the diff --git a/Web App/web/src/api.js b/Web App/web/src/api.js index ca40a6c..223e81f 100644 --- a/Web App/web/src/api.js +++ b/Web App/web/src/api.js @@ -296,6 +296,9 @@ export const api = { request(`/cars/${carId}/provider`, { method: "POST", body: JSON.stringify(body) }), syncCarProvider: (carId, body = {}) => request(`/cars/${carId}/provider/sync`, { method: "POST", body: JSON.stringify(body) }), + // Automatic odometer updates: {enabled, intervalMinutes}. Returns the car. + setCarOdometerAutoSync: (carId, body) => + request(`/cars/${carId}/provider/auto-sync`, { method: "PUT", body: JSON.stringify(body) }), // Charger providers — the garage's import, aimed at the wall: a charger on a // connected service (Anker Solix, Greencell) becomes one of the caller's own diff --git a/Web App/web/src/components/OdometerAutoSync.vue b/Web App/web/src/components/OdometerAutoSync.vue new file mode 100644 index 0000000..62ce5ee --- /dev/null +++ b/Web App/web/src/components/OdometerAutoSync.vue @@ -0,0 +1,79 @@ + + + diff --git a/Web App/web/src/components/ProviderPanel.vue b/Web App/web/src/components/ProviderPanel.vue index 31ad23b..71d7531 100644 --- a/Web App/web/src/components/ProviderPanel.vue +++ b/Web App/web/src/components/ProviderPanel.vue @@ -14,6 +14,7 @@ import { api } from "../api"; import { prefs } from "../prefs"; import { t } from "../i18n"; import { askConfirm } from "../lib/confirm.js"; +import OdometerAutoSync from "./OdometerAutoSync.vue"; import { formatDateTime, formatKm } from "../lib/format.js"; const props = defineProps({ @@ -316,6 +317,18 @@ onMounted(async () => {

{{ snap.detail }}

{{ t("car.provider.own") }}

+ +