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>
583 lines
21 KiB
Go
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)})
|
|
}
|