Load the new version of the webinterface when device got updated

ffreddow · ffreddow · commit e38d4f8a40f9 · 2025-09-10T15:33:55.000+02:00
Fixes #215
diff --git a/backend/src/api_docs.rs b/backend/src/api_docs.rs
@@ -82,7 +82,7 @@ async fn main() {
             routes::auth::register::register,
             routes::auth::verify::verify,
             routes::auth::generate_salt::generate_salt,
-            routes::auth:: jwt_refresh::jwt_refresh,
+            routes::auth::jwt_refresh::jwt_refresh,
             routes::auth::get_login_salt::get_login_salt,
             routes::auth::recovery::recovery,
             routes::auth::start_recovery::start_recovery,
@@ -108,6 +108,7 @@ async fn main() {
             routes::check_expiration::check_expiration,
             routes::management::management,
             routes::send_chargelog_to_user::send_chargelog,
+            routes::webinterface::get_webinterface,
         ),
         components(schemas(
             routes::auth::login::LoginSchema,
diff --git a/backend/src/routes/static_files.rs b/backend/src/routes/static_files.rs
diff --git a/backend/src/routes/webinterface.rs b/backend/src/routes/webinterface.rs
@@ -0,0 +1,88 @@
+/* esp32-remote-access
+ * Copyright (C) 2025 Frederic Henrichs <frederic@tinkerforge.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+use actix_files::NamedFile;
+use actix_web::{get, web, Result};
+use utoipa::IntoParams;
+use std::path::PathBuf;
+
+use crate::utils::{get_charger_from_db, parse_uuid};
+
+#[cfg(not(debug_assertions))]
+const STATIC_SERVE_FROM: &str = "/static/";
+
+fn get_file(filename: String) -> Result<NamedFile> {
+    let path: PathBuf = filename.parse().unwrap();
+
+    #[cfg(debug_assertions)]
+    let static_serve_from = {
+        let env =
+            std::env::var("WARP_CHARGER_GIT_PATH").unwrap_or_else(|_| "warp-charger".to_string());
+        format!("{env}/firmwares/static_html/")
+    };
+    #[cfg(not(debug_assertions))]
+    let static_serve_from = "/static/";
+
+    let base_path = PathBuf::from(static_serve_from);
+    let full_path = base_path.join(&path);
+
+    let file = NamedFile::open(full_path)?;
+    Ok(file)
+}
+
+#[derive(serde::Deserialize, serde::Serialize, IntoParams)]
+pub struct StaticFileQuery {
+    #[param(example = "550e8400-e29b-41d4-a716-446655440000")]
+    charger: String,
+}
+
+#[utoipa::path(
+    params(
+        StaticFileQuery
+    ),
+    responses(
+        (status = 200, description = "Webinterface HTML file"),
+        (status = 400, description = "Invalid UUID format"),
+        (status = 401, description = "Unauthorized"),
+        (status = 404, description = "File not found"),
+        (status = 500, description = "Internal server error"),
+    ),
+    security(
+        ("jwt" = [])
+    )
+)]
+#[get("/webinterface")]
+pub async fn get_webinterface(
+    query: web::Query<StaticFileQuery>,
+    user: crate::models::uuid::Uuid,
+    state: web::Data<crate::AppState>,
+) -> Result<NamedFile> {
+    let charger = parse_uuid(&query.charger)?;
+    let user: uuid::Uuid = user.into();
+
+    if !crate::routes::charger::user_is_allowed(&state, user, charger).await? {
+        return Err(actix_web::error::ErrorUnauthorized("Unauthorized"));
+    }
+
+    let charger = get_charger_from_db(charger, &state).await?;
+    let firmware = charger.firmware_version.replace('+', "_");
+    let firmware = firmware.replace('.', "_");
+    let firmware = format!("{firmware}_index.html");
+    get_file(firmware)
+}
diff --git a/frontend/src/pages/Frame.tsx b/frontend/src/pages/Frame.tsx
@@ -154,9 +154,11 @@ class VirtualNetworkInterface {
             switch (e.data) {
                 case "ready":
                     this.setParentState.parentState({connection_state: ConnectionState.LoadingWebinterface});
-                    const firmware_version = this.chargerInfo.firmware_version;
                     const iframe = document.getElementById("interface") as HTMLIFrameElement;
-                    iframe.src = `/wg-${this.id}/${this.path}?firmware_version=${encodeURIComponent(firmware_version)}`;
+                    const urlParams = new URLSearchParams([
+                        ['charger', this.chargerInfo.id],
+                    ]);
+                    iframe.src = `/wg-${this.id}/${this.path}?${urlParams.toString()}`;
                     iframe.addEventListener("load", () => {
                         clearTimeout(this.timeout);
                         this.setParentState.parentState({show_spinner: false});
diff --git a/frontend/src/schema.d.ts b/frontend/src/schema.d.ts
@@ -501,6 +501,22 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/webinterface": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: operations["get_webinterface"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
 }
 export type webhooks = Record<string, never>;
 export interface components {
@@ -1590,4 +1606,53 @@ export interface operations {
             };
         };
     };
+    get_webinterface: {
+        parameters: {
+            query: {
+                /** @example 550e8400-e29b-41d4-a716-446655440000 */
+                charger: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Webinterface HTML file */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Invalid UUID format */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Unauthorized */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description File not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Internal server error */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
 }
diff --git a/frontend/src/sw.ts b/frontend/src/sw.ts
@@ -28,27 +28,31 @@ function handleWGRequest(event: FetchEvent) {
         headers1.push([key, val]);
     });
     if (event.request.headers.has("X-Connection-Id") || url.startsWith("/wg-")) {
-        let receiver_id = "";
-        let firmware_version: string | null = null;
+        let receiverId = "";
+        let chargerId: string | null = null;
         if (url.startsWith("/wg-")) {
             url = url.replace("/wg-", "");
             const first = url.indexOf("/");
-            receiver_id = url.substring(0, first);
-            url = url.replace(receiver_id, "");
+            receiverId = url.substring(0, first);
+            url = url.replace(receiverId, "");
             const parsedUrl = new URL(url, self.location.origin);
-            firmware_version = parsedUrl.searchParams.get("firmware_version");
-            firmware_version = firmware_version?.replace("+", "_") || null;
-            firmware_version = firmware_version?.replaceAll(".", "_") || null;
+            chargerId = parsedUrl.searchParams.get("charger");
             if (parsedUrl.pathname !== "/") {
-                firmware_version = null;
                 url = parsedUrl.pathname;
             }
         } else {
-            receiver_id = event.request.headers.get("X-Connection-Id") as string;
+            receiverId = event.request.headers.get("X-Connection-Id") as string;
         }
         const promise: Promise<Response> = new Promise(async (resolve) => {
-            if (firmware_version) {
-                const response = await fetch(`/api/static/${firmware_version}_index.html`);
+            if (chargerId) {
+                const params = new URLSearchParams([
+                    ['charger', chargerId]
+                ]);
+                const req = new Request(`/api/webinterface?${params.toString()}`, {cache: 'no-cache'});
+                const response = await fetch(req, {
+                    method: 'GET',
+                    headers: new Headers(headers1)
+                });
                 if (response.status === 200) {
                     const ds = new DecompressionStream("gzip");
                     const stream = response.body?.pipeThrough(ds);
@@ -77,7 +81,7 @@ function handleWGRequest(event: FetchEvent) {
                 url
             };
             const msg: Message = {
-                receiver_id,
+                receiver_id: receiverId,
                 id,
                 type: MessageType.Fetch,
                 data: message
