package api import ( "context" "encoding/json" "net/http" "net/url" "strings" "drivervault/apiserver/internal/plugins/builtin/toyota" ) // Integrations exposes the Toyota Connected Europe plugin to end users under a // three-layer cascade so that everyone can run it under their own MyToyota // account, while a superadmin (and, in an organization, an org admin) can impose // settings from above. // // The one connector serves three brands — Toyota, Lexus and Subaru — and each is // a plugin of its own to the user (toyota.Brands): its own panel entry, its own // settings card, its own credentials and enable flag under its own // pluginSettings key, and its own /api/integrations/{brand} routes. Everything // below is written once and parameterized by the brand. // // Resolution is a cascade: the top layer wins, and a lower layer only fills a // field the layers above left blank. // // - global (L1): pluginSettings on the app_settings singleton, set in the API // Server panel by a superadmin. This is the top of the cascade for everyone. // - org (L2): pluginSettings.{brand} on the caller's organization record, // editable by an org admin. Present only for users who belong to an org. // - user (L3): pluginSettings.{brand} on the caller's own user record. // // So the effective cascade is: // - org user: global → org → user // - org-less user: global → user // // The MyToyota username + password resolve together as a *pair* from the highest // layer that supplies a username, so credential halves are never mixed across // layers. Enablement is strictly per-user (L3), // gated by the global master switch (the plugin being enabled in the panel) and, // for org users, by the org gate. // // Secrets (and inherited usernames) are never returned to a lower-privileged // client: the effective config is resolved server-side and only masked values // leave the API. The live probe runs server-side against the resolved config. const toyotaSecretMask = "••••••••" // vehicleBrand is one face of the Toyota Connected Europe connector. type vehicleBrand = toyota.Brand // toyotaBrand is the MyToyota face, the one that predates the split. var toyotaBrand = toyota.Brands[0] // brandByName finds a registered brand by its plugin name. func brandByName(name string) (vehicleBrand, bool) { for _, b := range toyota.Brands { if b.Name == name { return b, true } } return vehicleBrand{}, false } // toyotaConfig is one layer's settings for one brand. type toyotaConfig struct { Username string `json:"username"` Password string `json:"password"` // Brand is read only from settings saved before the brands were split, to // move them onto their own key (see splitLegacyBrand); nothing writes it. Brand string `json:"brand,omitempty"` } // toyotaStored is what we persist per user/org under pluginSettings.{brand}. type toyotaStored struct { Config toyotaConfig `json:"config"` // Enabled is the personal per-user opt-in (user layer). Default false. Enabled bool `json:"enabled"` // Disabled is the organization layer's off switch, stored inverted so that // absent == enabled. Only meaningful on the org record; ignored on user records. Disabled bool `json:"disabled,omitempty"` } // decodePluginSettings reads a pluginSettings blob into its per-plugin entries, // with any pre-split brand entry already moved onto its own key. Never nil. func decodePluginSettings(raw json.RawMessage) map[string]json.RawMessage { doc := map[string]json.RawMessage{} if len(raw) > 0 { _ = json.Unmarshal(raw, &doc) } if doc == nil { doc = map[string]json.RawMessage{} // raw was JSON null } splitLegacyBrand(doc) return doc } // splitLegacyBrand moves a pre-split entry onto its brand. Before Lexus and // Subaru were plugins of their own, all three brands lived under // pluginSettings.toyota with a brand field picking the login; an entry there // that names L or S is that brand's account, so it belongs under that brand's // key — left under toyota it would show a Lexus login on the Toyota card. The // move happens on every read, so it needs no migration step, and is written // back the first time the record is saved for any brand. func splitLegacyBrand(doc map[string]json.RawMessage) { raw, ok := doc[toyotaBrand.Name] if !ok { return } var ts toyotaStored if json.Unmarshal(raw, &ts) != nil { return } code := strings.ToUpper(strings.TrimSpace(ts.Config.Brand)) var target vehicleBrand for _, b := range toyota.Brands { if b.Code == code && b.Name != toyotaBrand.Name { target = b } } if target.Name == "" { return // a Toyota entry, or one from before the brand field existed } if _, taken := doc[target.Name]; !taken { ts.Config.Brand = "" moved, _ := json.Marshal(ts) doc[target.Name] = moved } delete(doc, toyotaBrand.Name) } // storedFor is one brand's entry in a pluginSettings blob. func storedFor(raw json.RawMessage, b vehicleBrand) toyotaStored { var ts toyotaStored if entry, ok := decodePluginSettings(raw)[b.Name]; ok { _ = json.Unmarshal(entry, &ts) } ts.Config.Brand = "" return ts } // toyotaFieldView is one field's resolved state for the UI. type toyotaFieldView struct { Effective string `json:"effective"` // resolved value in force (secrets/inherited creds masked) Own string `json:"own"` // the caller's own editable-layer value (secret masked) Source string `json:"source"` // global | org | user | unset Locked bool `json:"locked"` // set above the caller's editable layer } // toyotaResolution is the fully-resolved state of one brand for one caller. It captures // the effective cascade plus both editable layers (personal + organization), so // an org admin can manage each independently. type toyotaResolution struct { eff toyotaConfig // effective (unmasked) — used only server-side (probes) userOwn toyotaConfig // caller's personal (L3) values (unmasked) orgOwn toyotaConfig // organization (L2) values (unmasked) source map[string]string // field -> layer name (global|org|user|unset) isSuper bool // superadmin: manages the global layer in the panel canOrg bool // caller may edit the organization layer (org admin) available bool // global master switch (plugin enabled in the panel) orgEnabled bool // org gate (default true; gates the org's users) enabled bool // caller's personal enable flag } // toyotaLayerRank orders the cascade layers; a higher number is lower priority. var toyotaLayerRank = map[string]int{"global": 1, "org": 2, "user": 3} // resolveToyota computes one brand's cascade for a caller. userRaw is the // caller's pluginSettings blob (read from their user record). func (s *Server) resolveToyota(ctx context.Context, who *callerIdentity, userRaw json.RawMessage, b vehicleBrand) toyotaResolution { g, masterEnabled, _ := s.plugins.RawConfig(b.Name) gc := toyotaConfig{Username: g["username"], Password: g["password"]} var oStored toyotaStored if who.OrgID != "" { oStored, _ = s.orgToyota(ctx, who.OrgID, b) } oc := oStored.Config uStored := storedFor(userRaw, b) uc := uStored.Config res := toyotaResolution{ source: map[string]string{}, userOwn: uc, orgOwn: oc, isSuper: who.isSuperadmin(), // An org admin may edit the organization layer in addition to their own // personal layer. Requires the service account (org writes go through it). canOrg: who.isManager() && !who.isSuperadmin() && who.OrgID != "" && s.pb.Configured(), available: masterEnabled, orgEnabled: !oStored.Disabled, // default true; off only when the org disabled it enabled: uStored.Enabled, } // Ordered layers, top (highest priority) first. type layer struct { name string c toyotaConfig } layers := []layer{{"global", gc}} if who.OrgID != "" { layers = append(layers, layer{"org", oc}) } layers = append(layers, layer{"user", uc}) // Credentials resolve as a pair from the highest layer with a username, so // the username and password never come from different layers. credSrc := "unset" for _, l := range layers { if u := strings.TrimSpace(l.c.Username); u != "" { res.eff.Username, res.eff.Password, credSrc = u, l.c.Password, l.name break } } res.source["username"] = credSrc res.source["password"] = credSrc return res } // toyotaLockedFor reports whether a field whose value comes from source is locked // for a caller whose editable layer is editable (i.e. the value is set above them). func toyotaLockedFor(source, editable string) bool { if editable == "none" { return true // superadmin edits the global layer in the panel, not here } sr, ok := toyotaLayerRank[source] if !ok { return false // unset — the caller may be the first to set it } return sr < toyotaLayerRank[editable] } // toyotaMaskPresent returns the secret mask when v is non-empty, else "". func toyotaMaskPresent(v string) string { if strings.TrimSpace(v) != "" { return toyotaSecretMask } return "" } // orgToyota reads an organization's stored settings for one brand (config + the // org gate) and its raw pluginSettings blob via the service account. Best // effort: zero values on any miss so callers proceed as if the org layer were // empty. func (s *Server) orgToyota(ctx context.Context, orgID string, b vehicleBrand) (toyotaStored, json.RawMessage) { if orgID == "" || !s.pb.Configured() { return toyotaStored{}, nil } data, status, err := s.pb.Raw(ctx, http.MethodGet, "/api/collections/"+colOrgs+"/records/"+url.PathEscape(orgID)+"?fields=pluginSettings", nil) if err != nil || status != http.StatusOK { return toyotaStored{}, nil } var rec struct { PluginSettings json.RawMessage `json:"pluginSettings"` } _ = json.Unmarshal(data, &rec) return storedFor(rec.PluginSettings, b), rec.PluginSettings } // userPluginSettings reads a user's raw pluginSettings blob via the service // account. Best effort: nil on any miss. func (s *Server) userPluginSettings(ctx context.Context, id string) json.RawMessage { if id == "" || !s.pb.Configured() { return nil } var rec struct { PluginSettings json.RawMessage `json:"pluginSettings"` } if err := s.pb.GetOne(ctx, s.usersCollection(), id, &rec); err != nil { return nil } return rec.PluginSettings } // mergeToyota applies a mutation to one brand's entry of a pluginSettings blob, // preserving any other plugin keys, and returns the new blob. A pre-split entry // is moved onto its brand on the way through, so the save also migrates it. func mergeToyota(existing json.RawMessage, b vehicleBrand, apply func(*toyotaStored)) json.RawMessage { doc := decodePluginSettings(existing) var ts toyotaStored if raw, ok := doc[b.Name]; ok { _ = json.Unmarshal(raw, &ts) } apply(&ts) ts.Config.Brand = "" entry, _ := json.Marshal(ts) doc[b.Name] = entry out, _ := json.Marshal(doc) return out } // toyotaScopeView builds the masked field set for one editable scope. editable is // the layer the caller edits in this scope ("user" | "org" | "none"); a field is // locked when its effective value is set above that layer. func (s *Server) toyotaScopeView(res toyotaResolution, editable string) map[string]any { own := res.userOwn if editable == "org" { own = res.orgOwn } field := func(key, eff, ownv string, secret bool) toyotaFieldView { src := res.source[key] locked := toyotaLockedFor(src, editable) fv := toyotaFieldView{Source: src, Locked: locked} switch { case secret: // Never expose a secret; show only presence. fv.Effective, fv.Own = toyotaMaskPresent(eff), toyotaMaskPresent(ownv) case key == "username" && locked: // Inherited username — hide the concrete value from a lower layer. fv.Effective, fv.Own = toyotaMaskPresent(eff), toyotaMaskPresent(ownv) default: fv.Effective, fv.Own = eff, ownv } return fv } return map[string]any{ "editableLayer": editable, "fields": map[string]toyotaFieldView{ "username": field("username", res.eff.Username, own.Username, false), "password": field("password", res.eff.Password, own.Password, true), }, } } // toyotaView builds the masked, client-safe response body from a resolution. It // exposes a "user" scope for everyone plus, for org admins, an "org" scope — each // with its own locked-field state — so the UI can present the two independently. func (s *Server) toyotaView(who *callerIdentity, res toyotaResolution, b vehicleBrand) map[string]any { out := map[string]any{ "brand": b.Name, "make": b.Make, "app": b.App, "available": res.available, "orgEnabled": res.orgEnabled, "enabled": res.enabled, "role": who.Role, "orgId": who.OrgID, "canEditOrg": res.canOrg, "isSuperadmin": res.isSuper, } if res.isSuper { // Superadmin manages the global layer in the panel; here it is read-only. out["editableLayer"] = "none" out["scopes"] = map[string]any{"user": s.toyotaScopeView(res, "none")} return out } scopes := map[string]any{"user": s.toyotaScopeView(res, "user")} if res.canOrg { scopes["org"] = s.toyotaScopeView(res, "org") } out["scopes"] = scopes return out } // integrationBrand reads the brand segment of /api/integrations/{brand}. The // routes are registered once per brand, so a miss is a wiring mistake; it still // answers 404 rather than falling back to Toyota. func integrationBrand(w http.ResponseWriter, r *http.Request) (vehicleBrand, bool) { name := strings.TrimPrefix(r.URL.Path, "/api/integrations/") if i := strings.IndexByte(name, '/'); i >= 0 { name = name[:i] } b, ok := brandByName(name) if !ok { writeError(w, http.StatusNotFound, "unknown integration") } return b, ok } // GET /api/integrations/{toyota|lexus|subaru} — resolved view of one brand for // the caller. func (s *Server) handleGetToyota(w http.ResponseWriter, r *http.Request) { who := caller(r) if who == nil { writeError(w, http.StatusUnauthorized, "not authenticated") return } b, ok := integrationBrand(w, r) if !ok { return } userRaw := s.userPluginSettings(r.Context(), who.ID) res := s.resolveToyota(r.Context(), who, userRaw, b) writeJSON(w, http.StatusOK, s.toyotaView(who, res, b)) } // PUT /api/integrations/{toyota|lexus|subaru} — save the caller's editable layer // of one brand. Body: {enabled?: bool, scope?: "user"|"org", config?: {username, // password}}. Fields locked above the caller are ignored; a password left at the // mask is preserved. func (s *Server) handlePutToyota(w http.ResponseWriter, r *http.Request) { who := caller(r) if who == nil { writeError(w, http.StatusUnauthorized, "not authenticated") return } b, ok := integrationBrand(w, r) if !ok { return } if !s.pb.Configured() { writeError(w, http.StatusServiceUnavailable, "integration settings not configured on the server") return } var body struct { Enabled *bool `json:"enabled"` Scope string `json:"scope"` // "user" (default) | "org" (admins only) Config map[string]string `json:"config"` } if err := json.NewDecoder(r.Body).Decode(&body); err != nil { writeError(w, http.StatusBadRequest, "invalid json") return } userRaw := s.userPluginSettings(r.Context(), who.ID) res := s.resolveToyota(r.Context(), who, userRaw, b) // Resolve which layer this write targets. Everyone edits their own personal // (user) layer by default; an org admin may target the organization layer by // asking for scope "org". Superadmins are read-only here (they manage global // in the panel) and may only toggle their personal enable flag. editable := "user" switch { case res.isSuper: editable = "none" case strings.EqualFold(strings.TrimSpace(body.Scope), "org"): if !res.canOrg { writeError(w, http.StatusForbidden, "only an organization admin can edit organization settings") return } editable = "org" } // Build the new target-layer config from its current own values, overlaying // only fields the caller is allowed to change in this scope. newOwn := res.userOwn if editable == "org" { newOwn = res.orgOwn } applyField := func(key string, set func(*toyotaConfig, string)) { v, ok := body.Config[key] if !ok || toyotaLockedFor(res.source[key], editable) { return } if key == "password" && v == toyotaSecretMask { return // keep current secret } set(&newOwn, strings.TrimSpace(v)) } applyField("username", func(c *toyotaConfig, v string) { c.Username = v }) applyField("password", func(c *toyotaConfig, v string) { c.Password = v }) // Persist the organization layer (admins) via the service account. if editable == "org" { _, orgRaw := s.orgToyota(r.Context(), who.OrgID, b) newDoc := mergeToyota(orgRaw, b, func(ts *toyotaStored) { ts.Config = newOwn // In the org scope the enable flag is the org master switch, stored // inverted (disabled) so absent means enabled. if body.Enabled != nil { ts.Disabled = !*body.Enabled } }) _, st, err := s.pb.Raw(r.Context(), http.MethodPatch, "/api/collections/"+colOrgs+"/records/"+url.PathEscape(who.OrgID), map[string]json.RawMessage{"pluginSettings": newDoc}) if err != nil { writeUpstreamDown(w, err) return } if st != http.StatusOK { writeError(w, http.StatusBadGateway, "could not save organization settings") return } } // Persist the user record: the personal enable flag lives here (user/ // superadmin scope — in the org scope it targets the org gate instead), and // so does the personal config layer when this write targets the user scope. personalEnable := body.Enabled != nil && editable != "org" if personalEnable || editable == "user" { newDoc := mergeToyota(userRaw, b, func(ts *toyotaStored) { if personalEnable { ts.Enabled = *body.Enabled } if editable == "user" { ts.Config = newOwn } }) if err := s.pb.Update(r.Context(), s.usersCollection(), who.ID, map[string]any{"pluginSettings": newDoc}, nil); err != nil { writePBError(w, err) return } } // Re-resolve and return the fresh view. fresh := s.userPluginSettings(r.Context(), who.ID) res2 := s.resolveToyota(r.Context(), who, fresh, b) writeJSON(w, http.StatusOK, s.toyotaView(who, res2, b)) } // POST /api/integrations/{toyota|lexus|subaru}/health — live probe using the // caller's resolved config for that brand. Never returns secrets. func (s *Server) handleToyotaHealth(w http.ResponseWriter, r *http.Request) { who := caller(r) if who == nil { writeError(w, http.StatusUnauthorized, "not authenticated") return } b, ok := integrationBrand(w, r) if !ok { return } userRaw := s.userPluginSettings(r.Context(), who.ID) res := s.resolveToyota(r.Context(), who, userRaw, b) down := func(detail string) { writeJSON(w, http.StatusOK, map[string]any{"health": map[string]any{"status": "down", "detail": detail}}) } switch { case !res.available: down("The " + b.Make + " integration is disabled by the administrator") return case !res.orgEnabled: down("The " + b.Make + " integration is disabled for your organization") return case strings.TrimSpace(res.eff.Username) == "" || strings.TrimSpace(res.eff.Password) == "": down("Enter your " + b.App + " email and password to connect") return } cfg := map[string]string{ "username": res.eff.Username, "password": res.eff.Password, } h, err := s.plugins.HealthCheckWith(r.Context(), b.Name, cfg) if err != nil { writeJSON(w, http.StatusBadGateway, map[string]any{"error": err.Error()}) return } writeJSON(w, http.StatusOK, map[string]any{"health": h}) } // GET /api/integrations/{toyota|lexus|subaru}/vehicles — the caller's vehicles // on that brand's account as the // upstream returned them, fetched server-side under their resolved credentials. // Gated by the same switches as the settings view (global master, org gate, // personal opt-in, credentials present); when any gate is off it returns 200 with // an empty list plus a reason, so the UI can degrade quietly rather than error. // // The gate and its wording live in toyotaSource (vehicleproviders_toyota.go), so // this endpoint and the generic vehicle-provider endpoints cannot drift apart. // This one stays because it relays the raw payload; /api/vehicle-providers/ // toyota/vehicles returns the normalized, importable shape. func (s *Server) handleToyotaVehicles(w http.ResponseWriter, r *http.Request) { who := caller(r) if who == nil { writeError(w, http.StatusUnauthorized, "not authenticated") return } b, found := integrationBrand(w, r) if !found { return } userRaw := s.userPluginSettings(r.Context(), who.ID) cfg, ok, detail := toyotaSource{b}.gate(r.Context(), s, who, userRaw) if !ok { writeJSON(w, http.StatusOK, map[string]any{"vehicles": []any{}, "unavailable": true, "detail": detail}) return } raw, err := s.plugins.InvokeWith(r.Context(), b.Name, cfg, "vehicles", nil) if err != nil { writeJSON(w, http.StatusBadGateway, map[string]any{"error": err.Error()}) return } // Relay the upstream JSON verbatim under "vehicles". writeJSON(w, http.StatusOK, map[string]any{"vehicles": json.RawMessage(raw)}) }