More fixes

server-rs/src/routes/postcodes.rs

@@ -12,10 +12,12 @@ use tracing::info;
 use crate::aggregation::Aggregator;
 use crate::auth::OptionalUser;
 use crate::consts::MAX_CELLS_PER_REQUEST;
+use crate::data::travel_time::TravelData;
 use crate::licensing::check_license_bounds;
 use crate::parsing::{
     bounds_intersect, parse_field_indices, parse_filters, require_bounds, row_passes_filters,
 };
+use crate::routes::travel_time::{parse_travel_entries, TravelTimeAgg};
 use crate::state::AppState;
 
 #[derive(Serialize)]
@@ -31,6 +33,8 @@ pub struct PostcodeParams {
     filters: Option<String>,
     /// Comma-separated feature names to include in min/max aggregation.
     fields: Option<String>,
+    /// Pipe-separated travel time entries: `mode:slug|mode:slug:min:max`
+    travel: Option<String>,
 }
 
 /// Build a GeoJSON geometry object from postcode polygon rings.
@@ -84,10 +88,41 @@ pub async fn get_postcodes(
     let field_indices = parse_field_indices(params.fields.as_deref(), &state.feature_name_to_index)
         .map_err(|err| (err.0, err.1).into_response())?;
 
+    // Parse travel entries
+    let travel_entries = params
+        .travel
+        .as_deref()
+        .filter(|val| !val.is_empty())
+        .map(parse_travel_entries)
+        .transpose()
+        .map_err(|err| (StatusCode::BAD_REQUEST, err).into_response())?
+        .unwrap_or_default();
+
     let response = tokio::task::spawn_blocking(move || -> Result<PostcodesResponse, String> {
         let postcode_data = &state.postcode_data;
         let t0 = std::time::Instant::now();
 
+        // Load travel time data from precomputed parquet files
+        let travel_data: Vec<TravelData> = if !travel_entries.is_empty() {
+            let store = &state.travel_time_store;
+            travel_entries
+                .iter()
+                .map(|entry| {
+                    store
+                        .get(&entry.mode, &entry.slug)
+                        .map_err(|err| format!("Failed to load travel data: {}", err))
+                })
+                .collect::<Result<Vec<_>, _>>()?
+        } else {
+            Vec::new()
+        };
+
+        let has_travel = !travel_entries.is_empty();
+        let travel_field_keys: Vec<String> = travel_entries
+            .iter()
+            .map(|te| format!("tt_{}_{}", te.mode, te.slug))
+            .collect();
+
         let num_features = state.data.num_features;
         let feature_data = &state.data.feature_data;
         let min_keys = &state.min_keys;
@@ -122,9 +157,35 @@ pub async fn get_postcodes(
                 }
             });
 
+        // Filter postcodes by travel time range (if specified)
+        if has_travel {
+            postcode_rows.retain(|&pc_idx, _rows| {
+                let postcode = &postcode_data.postcodes[pc_idx];
+                for (ti, entry) in travel_entries.iter().enumerate() {
+                    if let (Some(fmin), Some(fmax)) = (entry.filter_min, entry.filter_max) {
+                        let minutes = travel_data[ti].get(postcode.as_str()).map(|r| {
+                            if entry.use_best {
+                                r.best_minutes.unwrap_or(r.minutes)
+                            } else {
+                                r.minutes
+                            }
+                        });
+                        match minutes {
+                            Some(mins) if (mins as f32) >= fmin && (mins as f32) <= fmax => {}
+                            _ => return false,
+                        }
+                    }
+                }
+                true
+            });
+        }
+
         // Aggregate for each postcode that has properties in bounds
         // (polygon intersection check happens later when building response)
         let mut postcode_aggs: FxHashMap<usize, Aggregator> = FxHashMap::default();
+        // Travel time aggregation per postcode
+        let mut travel_aggs: FxHashMap<usize, Vec<TravelTimeAgg>> = FxHashMap::default();
+
         for (&pc_idx, rows) in &postcode_rows {
             let agg = postcode_aggs
                 .entry(pc_idx)
@@ -136,6 +197,24 @@ pub async fn get_postcodes(
                     agg.add_row(feature_data, row, num_features);
                 }
             }
+
+            // Aggregate travel times for this postcode
+            if has_travel {
+                let postcode = &postcode_data.postcodes[pc_idx];
+                let tt_aggs = travel_aggs
+                    .entry(pc_idx)
+                    .or_insert_with(|| (0..travel_entries.len()).map(|_| TravelTimeAgg::new()).collect());
+                for (ti, entry) in travel_entries.iter().enumerate() {
+                    if let Some(row_data) = travel_data[ti].get(postcode.as_str()) {
+                        let minutes = if entry.use_best {
+                            row_data.best_minutes.unwrap_or(row_data.minutes)
+                        } else {
+                            row_data.minutes
+                        };
+                        tt_aggs[ti].add(minutes as f32);
+                    }
+                }
+            }
         }
 
         // Build response, filtering postcodes to only those whose polygon intersects query bounds
@@ -218,6 +297,25 @@ pub async fn get_postcodes(
                 }
             }
 
+            // Add travel time aggregation fields
+            if let Some(tt_aggs) = travel_aggs.get(&pc_idx) {
+                for (ti, agg) in tt_aggs.iter().enumerate() {
+                    if agg.count > 0 {
+                        let key = &travel_field_keys[ti];
+                        let avg = agg.sum / agg.count as f64;
+                        if let Some(nm) = serde_json::Number::from_f64(agg.min as f64) {
+                            props.insert(format!("min_{key}"), Value::Number(nm));
+                        }
+                        if let Some(nm) = serde_json::Number::from_f64(agg.max as f64) {
+                            props.insert(format!("max_{key}"), Value::Number(nm));
+                        }
+                        if let Some(nm) = serde_json::Number::from_f64(avg) {
+                            props.insert(format!("avg_{key}"), Value::Number(nm));
+                        }
+                    }
+                }
+            }
+
             // Build GeoJSON Feature
             let mut feature = Map::new();
             feature.insert("type".into(), Value::String("Feature".into()));
@@ -241,6 +339,7 @@ pub async fn get_postcodes(
             bounds = format_args!("{:.6},{:.6},{:.6},{:.6}", south, west, north, east),
             filters = num_filters,
             filters_raw = filters_str.as_deref().unwrap_or("-"),
+            travel_entries = travel_entries.len(),
             total_ms = format_args!("{:.1}", t_total.as_secs_f64() * 1000.0),
             "GET /api/postcodes"
         );