Config UI: publish updated sponsor and interval values, reboot hint

server/http.go

@@ -285,9 +285,9 @@ func (s *HTTPd) RegisterSystemHandler(site *core.Site, valueChan chan<- util.Par
 			"deletedevice":       {"DELETE", "/devices/{class:[a-z]+}/{id:[0-9.]+}", deleteDeviceHandler(site)},
 			"testconfig":         {"POST", "/test/{class:[a-z]+}", testConfigHandler},
 			"testmerged":         {"POST", "/test/{class:[a-z]+}/merge/{id:[0-9.]+}", testConfigHandler},
-			"interval":           {"POST", "/interval/{value:[0-9.]+}", settingsSetDurationHandler(keys.Interval)},
-			"updatesponsortoken": {"POST", "/sponsortoken", updateSponsortokenHandler},
-			"deletesponsortoken": {"DELETE", "/sponsortoken", deleteSponsorTokenHandler},
+			"interval":           {"POST", "/interval/{value:[0-9.]+}", settingsSetDurationHandler(keys.Interval, valueChan)},
+			"updatesponsortoken": {"POST", "/sponsortoken", updateSponsortokenHandler(valueChan)},
+			"deletesponsortoken": {"DELETE", "/sponsortoken", deleteSponsorTokenHandler(valueChan)},
 		}
 
 		// yaml handlers

server/http_config_site_other_handler.go

@@ -6,36 +6,48 @@ import (
 
 	"github.com/evcc-io/evcc/core/keys"
 	"github.com/evcc-io/evcc/server/db/settings"
+	"github.com/evcc-io/evcc/util"
 	"github.com/evcc-io/evcc/util/sponsor"
 )
 
-func updateSponsortokenHandler(w http.ResponseWriter, r *http.Request) {
-	var req struct {
-		Token string `json:"token"`
-	}
-
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		jsonError(w, http.StatusBadRequest, err)
-		return
-	}
+func updateSponsortokenHandler(valueChan chan<- util.Param) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req struct {
+			Token string `json:"token"`
+		}
 
-	if req.Token != "" {
-		if err := sponsor.ConfigureSponsorship(req.Token); err != nil {
+		if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
 			jsonError(w, http.StatusBadRequest, err)
 			return
 		}
-		sponsor.SetFromYaml(false)
-	}
 
-	// TODO find better place
-	settings.SetString(keys.SponsorToken, req.Token)
-	setConfigDirty()
+		if req.Token != "" {
+			if err := sponsor.ConfigureSponsorship(req.Token); err != nil {
+				jsonError(w, http.StatusBadRequest, err)
+				return
+			}
+			sponsor.SetFromYaml(false)
+		}
+
+		// TODO find better place
+		settings.SetString(keys.SponsorToken, req.Token)
+		setConfigDirty()
+
+		status := sponsor.Status()
+		valueChan <- util.Param{Key: keys.Sponsor, Val: status}
 
-	jsonWrite(w, sponsor.Status())
+		jsonWrite(w, status)
+	}
 }
 
-func deleteSponsorTokenHandler(w http.ResponseWriter, r *http.Request) {
-	settings.SetString(keys.SponsorToken, "")
-	setConfigDirty()
-	jsonWrite(w, true)
+func deleteSponsorTokenHandler(valueChan chan<- util.Param) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		settings.SetString(keys.SponsorToken, "")
+		setConfigDirty()
+
+		status := sponsor.Status()
+		valueChan <- util.Param{Key: keys.Sponsor, Val: status}
+
+		jsonWrite(w, true)
+	}
 }

server/http_global_settings_handler.go

@@ -28,7 +28,7 @@ func settingsDeleteHandler(key string) http.HandlerFunc {
 	}
 }
 
-func settingsSetDurationHandler(key string) http.HandlerFunc {
+func settingsSetDurationHandler(key string, valueChan chan<- util.Param) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		vars := mux.Vars(r)
 
@@ -41,6 +41,8 @@ func settingsSetDurationHandler(key string) http.HandlerFunc {
 		settings.SetInt(key, int64(time.Second*time.Duration(val)))
 		setConfigDirty()
 
+		valueChan <- util.Param{Key: key, Val: val}
+
 		jsonWrite(w, val)
 	}
 }

tests/config-control.spec.ts

@@ -0,0 +1,79 @@
+import { test, expect } from "@playwright/test";
+import { start, stop, baseUrl } from "./evcc";
+import { enableExperimental, expectModalVisible, expectModalHidden } from "./utils";
+
+test.use({ baseURL: baseUrl() });
+
+test.afterEach(async () => {
+  await stop();
+});
+
+test.describe("control settings (interval)", () => {
+  test("interval is immediately visible after save without restart", async ({ page }) => {
+    await start();
+    await page.goto("/#/config");
+    await enableExperimental(page);
+
+    // Initially, control entry should show default interval (30s)
+    const controlEntry = page.getByTestId("generalconfig-control");
+    await expect(controlEntry).toContainText("30");
+
+    // Open control modal
+    await controlEntry.getByRole("button", { name: "Edit" }).click();
+
+    const modal = page.locator("#controlModal");
+    await expectModalVisible(modal);
+
+    // Change interval to 60 seconds
+    const intervalInput = modal.getByLabel("Interval");
+    await expect(intervalInput).toHaveValue("30");
+    await intervalInput.fill("60");
+
+    // Save the changes
+    await modal.getByRole("button", { name: "Save" }).click();
+
+    // Modal should close
+    await expectModalHidden(modal);
+
+    // The control entry should now show the new interval value (60s) without restart
+    await expect(controlEntry).toContainText("60");
+    await expect(controlEntry).not.toContainText("30");
+
+    // Verify by opening the modal again
+    await controlEntry.getByRole("button", { name: "Edit" }).click();
+    await expectModalVisible(modal);
+    await expect(intervalInput).toHaveValue("60");
+  });
+
+  test("residual power is immediately visible after save", async ({ page }) => {
+    await start();
+    await page.goto("/#/config");
+    await enableExperimental(page);
+
+    // Open control modal
+    const controlEntry = page.getByTestId("generalconfig-control");
+    await controlEntry.getByRole("button", { name: "Edit" }).click();
+
+    const modal = page.locator("#controlModal");
+    await expectModalVisible(modal);
+
+    // Get initial residual power value
+    const residualPowerInput = modal.getByLabel("Residual power");
+    const initialValue = await residualPowerInput.inputValue();
+
+    // Change residual power to 200W
+    await residualPowerInput.fill("200");
+
+    // Save the changes
+    await modal.getByRole("button", { name: "Save" }).click();
+
+    // Modal should close
+    await expectModalHidden(modal);
+
+    // Verify by opening the modal again
+    await controlEntry.getByRole("button", { name: "Edit" }).click();
+    await expectModalVisible(modal);
+    await expect(residualPowerInput).toHaveValue("200");
+    await expect(residualPowerInput).not.toHaveValue(initialValue);
+  });
+});

tests/sponsor.spec.ts

@@ -77,4 +77,35 @@
     await modal.getByRole("button", { name: "Save" }).click();
     await expect(modal).toContainText("token is expired");
   });
+
+  test("token is immediately visible after save without restart", async ({ page }) => {
+    await start();
+    await page.goto("/#/config");
+    await enableExperimental(page);
+
+    // Initially, sponsoring entry should show "---" (no sponsor)
+    const sponsorEntry = page.getByTestId("generalconfig-sponsoring");
+    await expect(sponsorEntry).toContainText("---");
+
+    // Open sponsor modal and enter expired token (will be saved despite being invalid)
+    await sponsorEntry.getByRole("button", { name: "Edit" }).click();
+
+    const modal = page.getByTestId("sponsor-modal");
+    const textarea = modal.getByRole("textbox", { name: "Enter your token" });
+
+    await textarea.fill(EXPIRED_TOKEN);
+    await modal.getByRole("button", { name: "Save" }).click();
+
+    // After save, the modal should close and show error in the entry (NOT "---")
+    // The token should be immediately visible in the UI without restart
+    await expect(modal).not.toBeVisible();
+
+    // The sponsor entry should now show "invalid" instead of "---"
+    await expect(sponsorEntry).toContainText("invalid");
+    await expect(sponsorEntry).not.toContainText("---");
+
+    // Verify by opening the modal again
+    await sponsorEntry.getByRole("button", { name: "Edit" }).click();
+    await expect(modal.getByRole("textbox", { name: "Your token" })).toHaveValue(SHORT_TOKEN);
+  });
 });