feat(energy): pörssisähkö spot-price section

Adds a public, keyless spot-price upstream (spot-hinta.fi), aggregated
15-min → hourly and served at GET /api/spot (today + tomorrow, c/kWh).

Frontend: first section of the energy tab — two slim per-hour bar charts
(today/tomorrow), absolute green→red→purple colour by price with shared
heights, current hour outlined, past greyed, per-day min–max, hover price,
today's average, and a tap-to-toggle gradient legend. Mobile-safe.

Author: eetu

backend/src/lib.rs

@@ -4,6 +4,7 @@ pub mod pv;
 pub mod reserve;
 pub mod settings;
 pub mod solis;
+pub mod spot;
 pub mod storage;
 pub mod weather;
 
@@ -28,6 +29,7 @@ pub struct AppState {
     pub weather_cache: Cache<weather::models::WeatherResponse>,
     pub solis_cache: Cache<solis::models::SolisWidgetData>,
     pub pv_cache: Cache<pv::models::PvForecast>,
+    pub spot_cache: Cache<spot::models::SpotResponse>,
     pub hue_events_tx: broadcast::Sender<hue::events::HueLiveEvent>,
     pub storage: storage::Storage,
 }
@@ -48,6 +50,7 @@ pub struct AppState {
         pv::handlers::get_forecast,
         pv::handlers::post_forecast,
         reserve::handlers::get_reserve,
+        spot::handlers::get_spot,
         status,
         sensor_history,
     ),
@@ -67,6 +70,8 @@ pub struct AppState {
         pv::models::PvPoint,
         reserve::models::ReserveResponse,
         reserve::models::ReservePoint,
+        spot::models::SpotResponse,
+        spot::models::HourPrice,
         StatusResponse,
         storage::SensorReading,
     ))
@@ -224,7 +229,8 @@ pub fn create_app(
                 )
                 .service(
                     web::scope("/reserve").route("", web::get().to(reserve::handlers::get_reserve)),
-                ),
+                )
+                .service(web::scope("/spot").route("", web::get().to(spot::handlers::get_spot))),
         )
         .service(SwaggerUi::new("/docs/{_:.*}").url("/api-doc/openapi.json", openapi))
         .service({
@@ -268,6 +274,7 @@ pub fn create_test_app_state_with(settings: Settings) -> Arc<AppState> {
         weather_cache: Cache::new(std::time::Duration::from_secs(3600)),
         solis_cache: Cache::new(std::time::Duration::from_secs(300)),
         pv_cache: Cache::new(std::time::Duration::from_secs(60)),
+        spot_cache: Cache::new(std::time::Duration::from_secs(1800)),
         hue_events_tx,
         storage,
     })
@@ -307,6 +314,7 @@ pub async fn run_server() -> std::io::Result<()> {
         weather_cache: Cache::new(std::time::Duration::from_secs(3600)),
         solis_cache: Cache::new(std::time::Duration::from_secs(300)),
         pv_cache: Cache::new(std::time::Duration::from_secs(60)),
+        spot_cache: Cache::new(std::time::Duration::from_secs(1800)),
         hue_events_tx: hue_events_tx.clone(),
         storage,
     });

backend/src/settings.rs

@@ -18,6 +18,7 @@ pub struct Settings {
     /// Default provider key for the reserve tables. Generic default; a local
     /// deploy can set RESERVE_PROVIDER to a real name to match its updater.
     pub reserve_provider: String,
+    pub spot_base_url: String,
 }
 
 impl Settings {
@@ -38,6 +39,7 @@ impl Settings {
             solis_station_id: String::new(),
             solis_base_url: "https://www.soliscloud.com:13333".into(),
             reserve_provider: "reserve".into(),
+            spot_base_url: "https://api.spot-hinta.fi".into(),
         }
     }
 
@@ -71,6 +73,8 @@ impl Settings {
             solis_base_url: env::var("SOLIS_BASE_URL")
                 .unwrap_or_else(|_| "https://www.soliscloud.com:13333".into()),
             reserve_provider: env::var("RESERVE_PROVIDER").unwrap_or_else(|_| "reserve".into()),
+            spot_base_url: env::var("SPOT_BASE_URL")
+                .unwrap_or_else(|_| "https://api.spot-hinta.fi".into()),
         }
     }
 }

backend/src/spot/client.rs

@@ -0,0 +1,75 @@
+use std::collections::BTreeMap;
+
+use chrono::{DateTime, FixedOffset, NaiveDate, Timelike};
+
+use super::models::{HourPrice, SpotEntry, SpotResponse};
+
+pub async fn fetch(
+    client: &reqwest::Client,
+    base_url: &str,
+) -> Result<SpotResponse, reqwest::Error> {
+    let url = format!("{}/TodayAndDayForward", base_url.trim_end_matches('/'));
+    let entries: Vec<SpotEntry> = client
+        .get(&url)
+        .send()
+        .await?
+        .error_for_status()?
+        .json()
+        .await?;
+    Ok(aggregate(entries))
+}
+
+/// Average the 15-min quarters into hourly bars and split into today/tomorrow
+/// (the two distinct local dates the upstream returns).
+fn aggregate(entries: Vec<SpotEntry>) -> SpotResponse {
+    // (local date, hour) -> (price sum, count, hour-start datetime)
+    let mut buckets: BTreeMap<(NaiveDate, u32), (f64, u32, DateTime<FixedOffset>)> =
+        BTreeMap::new();
+    for e in &entries {
+        let Ok(dt) = DateTime::parse_from_rfc3339(&e.date_time) else {
+            continue;
+        };
+        let hour_start = dt
+            .with_minute(0)
+            .and_then(|d| d.with_second(0))
+            .and_then(|d| d.with_nanosecond(0))
+            .unwrap_or(dt);
+        let slot = buckets
+            .entry((dt.date_naive(), dt.hour()))
+            .or_insert((0.0, 0, hour_start));
+        slot.0 += e.price_with_tax;
+        slot.1 += 1;
+    }
+
+    let mut dates: Vec<NaiveDate> = buckets.keys().map(|(d, _)| *d).collect();
+    dates.dedup(); // BTreeMap keys are sorted, so dups are adjacent
+
+    let to_hours = |target: Option<NaiveDate>| -> Vec<HourPrice> {
+        let Some(target) = target else {
+            return Vec::new();
+        };
+        buckets
+            .iter()
+            .filter(|((d, _), _)| *d == target)
+            .map(|(_, (sum, count, hour_start))| HourPrice {
+                hour: hour_start.to_rfc3339(),
+                price: (sum / *count as f64) * 100.0, // €/kWh -> c/kWh
+            })
+            .collect()
+    };
+
+    let today = to_hours(dates.first().copied());
+    let tomorrow = to_hours(dates.get(1).copied());
+    let today_average = if today.is_empty() {
+        0.0
+    } else {
+        today.iter().map(|h| h.price).sum::<f64>() / today.len() as f64
+    };
+
+    SpotResponse {
+        unit: "c/kWh".into(),
+        today,
+        tomorrow,
+        today_average,
+    }
+}

backend/src/spot/handlers.rs

@@ -0,0 +1,34 @@
+use std::sync::Arc;
+
+use actix_web::{web, HttpResponse};
+
+use crate::AppState;
+
+#[utoipa::path(
+    get,
+    path = "/api/spot",
+    responses(
+        (status = 200, description = "Finnish spot prices, today + tomorrow hourly", body = super::models::SpotResponse),
+        (status = 502, description = "Failed to fetch spot prices"),
+    )
+)]
+pub async fn get_spot(state: web::Data<Arc<AppState>>) -> HttpResponse {
+    if let Some(cached) = state.spot_cache.get("spot").await {
+        return HttpResponse::Ok().json(cached);
+    }
+
+    match super::client::fetch(&state.http_client, &state.settings.spot_base_url).await {
+        Ok(data) => {
+            state.spot_cache.set("spot".into(), data.clone()).await;
+            HttpResponse::Ok().json(data)
+        }
+        Err(e) => {
+            tracing::error!("Failed to fetch spot prices: {e}");
+            if let Some(stale) = state.spot_cache.get_stale("spot").await {
+                tracing::warn!("Returning stale spot prices");
+                return HttpResponse::Ok().json(stale);
+            }
+            HttpResponse::BadGateway().json(serde_json::json!({"error": e.to_string()}))
+        }
+    }
+}

backend/src/spot/mod.rs

@@ -0,0 +1,5 @@
+//! Finnish spot electricity prices — public, keyless upstream (spot-hinta.fi),
+//! fetched directly like the weather sources. 15-min data aggregated to hourly.
+pub mod client;
+pub mod handlers;
+pub mod models;

backend/src/spot/models.rs

@@ -0,0 +1,31 @@
+use serde::{Deserialize, Serialize};
+use utoipa::ToSchema;
+
+/// Raw entry from spot-hinta.fi `/TodayAndDayForward` (15-min resolution).
+#[derive(Debug, Deserialize)]
+pub struct SpotEntry {
+    #[serde(rename = "DateTime")]
+    pub date_time: String, // RFC3339 with local offset, e.g. 2026-06-14T00:15:00+03:00
+    #[serde(rename = "PriceWithTax", default)]
+    pub price_with_tax: f64, // €/kWh, incl. VAT
+}
+
+/// One hourly bar. `hour` is the local-time hour start (RFC3339); `price` is
+/// c/kWh incl. VAT (the 15-min quarters averaged).
+#[derive(Debug, Clone, Serialize, ToSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct HourPrice {
+    pub hour: String,
+    pub price: f64,
+}
+
+/// Today + tomorrow hourly spot prices. `tomorrow` is empty until the day-ahead
+/// auction publishes (~14:15 local).
+#[derive(Debug, Clone, Serialize, ToSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct SpotResponse {
+    pub unit: String,
+    pub today: Vec<HourPrice>,
+    pub tomorrow: Vec<HourPrice>,
+    pub today_average: f64,
+}

backend/tests/smoke.rs

@@ -59,6 +59,7 @@ fn test_settings_with_mock(mock_url: &str) -> Settings {
         solis_key_secret: "".into(),
         solis_station_id: "".into(),
         reserve_provider: "reserve".into(),
+        spot_base_url: mock_url.into(),
     }
 }
 

frontend/src/App.tsx

@@ -6,6 +6,7 @@ import CurrentTime from "./components/CurrentTime";
 import EnergyDailyHistory from "./components/Energy/DailyHistory";
 import EnergyFlow from "./components/Energy/Flow";
 import EnergyReserve from "./components/Energy/Reserve";
+import EnergySpotPrice from "./components/Energy/SpotPrice";
 import EnergySummary from "./components/Energy/Summary";
 import FmiWeatherBox from "./components/FmiWeatherBox";
 import History from "./components/History";
@@ -328,6 +329,7 @@ const App = () => {
                   gap: 16,
                 }}
               >
+                <EnergySpotPrice />
                 <EnergyFlow />
                 <EnergySummary />
                 <EnergyDailyHistory />