Files
DriverVault/API Server/internal/api/integrations.go
T
tajniak81andClaude Opus 5.5 914aeeee23 Toyota Connected: Toyota, Lexus and Subaru as three plugins
One connector, registered once per brand with the brand fixed, so the
panel, the Web App and the Phone App each list Toyota, Lexus and Subaru
separately: own card, own account, own enable switch, own
/api/integrations/{brand} routes and vehicle provider. The brand picker
is gone.

Settings saved before the split under pluginSettings.toyota with brand
L or S move onto their brand's key on read, and are written back on the
next save. Cars linked as provider "toyota" read through their make's
brand.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 10:32:35 +01:00

583 lines
21 KiB
Go

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)})
}