Format and lint

server-rs/src/routes/screenshot.rs

@@ -0,0 +1,80 @@
+use std::sync::Arc;
+
+use axum::extract::Query;
+use axum::http::{header, StatusCode};
+use axum::response::IntoResponse;
+use tracing::{info, warn};
+
+use crate::state::AppState;
+
+#[derive(serde::Deserialize)]
+pub struct ScreenshotQuery {
+    #[serde(rename = "v")]
+    view: Option<String>,
+    #[serde(rename = "f")]
+    filters: Option<String>,
+    poi: Option<String>,
+    tab: Option<String>,
+    /// When "1", renders the OG heading overlay on the screenshot
+    og: Option<String>,
+}
+
+pub async fn get_screenshot(
+    state: Arc<AppState>,
+    Query(query): Query<ScreenshotQuery>,
+) -> impl IntoResponse {
+    let screenshot_base = &state.screenshot_url;
+
+    let mut params = Vec::new();
+    if query.og.as_deref() == Some("1") {
+        params.push("og=1".to_string());
+    }
+    if let Some(ref val) = query.view {
+        params.push(format!("v={}", urlencoding::encode(val)));
+    }
+    if let Some(ref val) = query.filters {
+        params.push(format!("f={}", urlencoding::encode(val)));
+    }
+    if let Some(ref val) = query.poi {
+        params.push(format!("poi={}", urlencoding::encode(val)));
+    }
+    if let Some(ref val) = query.tab {
+        params.push(format!("tab={}", urlencoding::encode(val)));
+    }
+
+    let qs = if params.is_empty() {
+        String::new()
+    } else {
+        format!("?{}", params.join("&"))
+    };
+    let url = format!("{}/screenshot{}", screenshot_base, qs);
+    info!("Proxying screenshot request to: {}", url);
+
+    match state.http_client.get(&url).send().await {
+        Ok(resp) if resp.status().is_success() => match resp.bytes().await {
+            Ok(bytes) => (
+                StatusCode::OK,
+                [
+                    (header::CONTENT_TYPE, "image/png"),
+                    (header::CACHE_CONTROL, "public, max-age=86400"),
+                ],
+                bytes,
+            )
+                .into_response(),
+            Err(err) => {
+                warn!("Failed to read screenshot response: {}", err);
+                (StatusCode::BAD_GATEWAY, "Failed to read screenshot").into_response()
+            }
+        },
+        Ok(resp) => {
+            let status = resp.status();
+            let body = resp.text().await.unwrap_or_default();
+            warn!("Screenshot service returned status {}: {}", status, body);
+            (StatusCode::BAD_GATEWAY, "Screenshot service error").into_response()
+        }
+        Err(err) => {
+            warn!("Failed to reach screenshot service: {}", err);
+            (StatusCode::BAD_GATEWAY, "Screenshot service unavailable").into_response()
+        }
+    }
+}