webhook through event system, extract data-generators adapter

webhook route now emits WebhookDataReceived event instead of directly
mutating DataProjection and broadcasting. event_handler applies data
and pushes incremental DataUpdate.

clock/static_text generators extracted to data-generators crate behind
DataSourcePort. chrono removed from bootstrap. polling adapters grouped
into Adapters struct.

crates/bootstrap/Cargo.toml

@@ -19,5 +19,4 @@ anyhow.workspace = true
 tracing.workspace = true
 tracing-subscriber.workspace = true
 dotenvy.workspace = true
-chrono.workspace = true
-chrono-tz.workspace = true
+data-generators.workspace = true

crates/bootstrap/src/event_handler.rs

@@ -40,6 +40,37 @@ pub async fn run(
 
                 info!("layout changed, pushed screen update to clients");
             }
+            Ok(DomainEvent::WebhookDataReceived { source_id, data }) => {
+                let widgets = match config.list_widgets().await {
+                    Ok(w) => w,
+                    Err(e) => {
+                        error!(error = %e, "failed to fetch widgets for webhook");
+                        continue;
+                    }
+                };
+
+                let changed = projection
+                    .apply_poll_result(source_id, &data, &widgets)
+                    .await;
+
+                if !changed.is_empty() {
+                    let with_hints: Vec<_> = changed
+                        .iter()
+                        .filter_map(|(id, state)| {
+                            let hint = widgets.iter().find(|w| w.id == *id)?.display_hint.clone();
+                            Some((*id, hint, state.clone()))
+                        })
+                        .collect();
+                    if let Err(e) = broadcaster.push_data_update(&with_hints).await {
+                        error!(error = %e, "failed to push webhook data update");
+                    }
+                    info!(
+                        source_id,
+                        count = changed.len(),
+                        "webhook data received, pushed update"
+                    );
+                }
+            }
             Ok(DomainEvent::ThemeChanged { theme }) => {
                 if let Err(e) = broadcaster.push_theme_update(&theme).await {
                     error!(error = %e, "failed to push theme update");

crates/bootstrap/src/polling.rs

@@ -1,16 +1,14 @@
 use anyhow::Result;
 use application::DataProjection;
-use chrono::Utc;
-use chrono_tz::Tz;
 use config_sqlite::SqliteConfigStore;
+use data_generators::{ClockGenerator, StaticTextGenerator};
 use domain::{
-    BroadcastPort, ConfigRepository, DataSource, DataSourceConfig, DataSourcePort, DataSourceType,
-    Value, WidgetState,
+    BroadcastPort, ConfigRepository, DataSource, DataSourcePort, DataSourceType, Value, WidgetState,
 };
 use http_json::HttpJsonAdapter;
 use media_adapter::MediaAdapter;
 use rss_adapter::RssAdapter;
-use std::collections::{BTreeMap, HashMap};
+use std::collections::HashMap;
 use std::sync::Arc;
 use std::time::Duration;
 use tcp_server::TcpBroadcaster;
@@ -19,15 +17,63 @@ use tracing::{debug, info, warn};
 
 const SOURCE_REFRESH_INTERVAL: Duration = Duration::from_secs(30);
 
+#[derive(Clone)]
+struct Adapters {
+    http: Arc<HttpJsonAdapter>,
+    media: Arc<MediaAdapter>,
+    rss: Arc<RssAdapter>,
+    clock: Arc<ClockGenerator>,
+    static_text: Arc<StaticTextGenerator>,
+}
+
+impl Adapters {
+    async fn poll(&self, source: &DataSource) -> Result<Value> {
+        match source.source_type {
+            DataSourceType::HttpJson | DataSourceType::Weather => self
+                .http
+                .poll(source)
+                .await
+                .map_err(|e| anyhow::anyhow!("{e}")),
+            DataSourceType::Media => self
+                .media
+                .poll(source)
+                .await
+                .map_err(|e| anyhow::anyhow!("{e}")),
+            DataSourceType::Rss => self
+                .rss
+                .poll(source)
+                .await
+                .map_err(|e| anyhow::anyhow!("{e}")),
+            DataSourceType::Clock => self
+                .clock
+                .poll(source)
+                .await
+                .map_err(|e| anyhow::anyhow!("{e}")),
+            DataSourceType::StaticText => self
+                .static_text
+                .poll(source)
+                .await
+                .map_err(|e| anyhow::anyhow!("{e}")),
+            DataSourceType::Webhook => Err(anyhow::anyhow!(
+                "webhook sources are push-based, not polled"
+            )),
+        }
+    }
+}
+
 pub async fn run(
     config: Arc<SqliteConfigStore>,
     broadcaster: Arc<TcpBroadcaster>,
     projection: Arc<DataProjection>,
     _poll_interval_secs: u64,
 ) -> Result<()> {
-    let http_adapter = Arc::new(HttpJsonAdapter::new());
-    let media_adapter = Arc::new(MediaAdapter::new());
-    let rss_adapter = Arc::new(RssAdapter::new());
+    let adapters = Adapters {
+        http: Arc::new(HttpJsonAdapter::new()),
+        media: Arc::new(MediaAdapter::new()),
+        rss: Arc::new(RssAdapter::new()),
+        clock: Arc::new(ClockGenerator::new()),
+        static_text: Arc::new(StaticTextGenerator::new()),
+    };
 
     let mut running: HashMap<u16, JoinHandle<()>> = HashMap::new();
 
@@ -64,9 +110,7 @@ pub async fn run(
             let config = config.clone();
             let broadcaster = broadcaster.clone();
             let projection = projection.clone();
-            let http = http_adapter.clone();
-            let media = media_adapter.clone();
-            let rss = rss_adapter.clone();
+            let adapters = adapters.clone();
 
             info!(
                 source_id = source.id,
@@ -76,7 +120,7 @@ pub async fn run(
             );
 
             let handle = tokio::spawn(async move {
-                poll_loop(source, config, broadcaster, projection, http, media, rss).await;
+                poll_loop(source, config, broadcaster, projection, adapters).await;
             });
 
             running.insert(source_id, handle);
@@ -95,16 +139,14 @@ async fn poll_loop(
     config: Arc<SqliteConfigStore>,
     broadcaster: Arc<TcpBroadcaster>,
     projection: Arc<DataProjection>,
-    http_adapter: Arc<HttpJsonAdapter>,
-    media_adapter: Arc<MediaAdapter>,
-    rss_adapter: Arc<RssAdapter>,
+    adapters: Adapters,
 ) {
     let interval = source.poll_interval;
 
     loop {
         tokio::time::sleep(interval).await;
 
-        let result = match poll_source(&http_adapter, &media_adapter, &rss_adapter, &source).await {
+        let result = match adapters.poll(&source).await {
             Ok(v) => v,
             Err(e) => {
                 warn!(source = %source.name, error = %e, "poll failed");
@@ -139,53 +181,3 @@ async fn poll_loop(
         }
     }
 }
-
-async fn poll_source(
-    http_adapter: &HttpJsonAdapter,
-    media_adapter: &MediaAdapter,
-    rss_adapter: &RssAdapter,
-    source: &DataSource,
-) -> Result<Value> {
-    match source.source_type {
-        DataSourceType::HttpJson | DataSourceType::Weather => http_adapter
-            .poll(source)
-            .await
-            .map_err(|e| anyhow::anyhow!("{e}")),
-        DataSourceType::Media => media_adapter
-            .poll(source)
-            .await
-            .map_err(|e| anyhow::anyhow!("{e}")),
-        DataSourceType::Rss => rss_adapter
-            .poll(source)
-            .await
-            .map_err(|e| anyhow::anyhow!("{e}")),
-        DataSourceType::Clock => Ok(generate_clock(&source.config)),
-        DataSourceType::StaticText => Ok(generate_static_text(&source.config)),
-        DataSourceType::Webhook => Err(anyhow::anyhow!(
-            "webhook sources are push-based, not polled"
-        )),
-    }
-}
-
-fn generate_clock(config: &DataSourceConfig) -> Value {
-    let (fmt, tz_name) = match config {
-        DataSourceConfig::Clock { format, timezone } => (format.as_str(), timezone.as_str()),
-        _ => ("%H:%M:%S", "UTC"),
-    };
-    let tz: Tz = tz_name.parse().unwrap_or(chrono_tz::UTC);
-    let now = Utc::now().with_timezone(&tz);
-    let formatted = now.format(fmt).to_string();
-    let mut map = BTreeMap::new();
-    map.insert("time".into(), Value::String(formatted));
-    Value::Object(map)
-}
-
-fn generate_static_text(config: &DataSourceConfig) -> Value {
-    let text = match config {
-        DataSourceConfig::StaticText { text } => text.clone(),
-        _ => String::new(),
-    };
-    let mut map = BTreeMap::new();
-    map.insert("text".into(), Value::String(text));
-    Value::Object(map)
-}