All good

server-rs/src/routes/actual_listings.rs

@@ -1,16 +1,20 @@
 use std::sync::Arc;
 
 use axum::extract::{Query, State};
-use axum::response::Json;
+use axum::response::{IntoResponse, Json, Response};
+use axum::Extension;
 use rustc_hash::FxHashSet;
 use serde::{Deserialize, Serialize};
 use tracing::info;
 
 use crate::api_error::ApiError;
+use crate::auth::OptionalUser;
+use crate::consts::NAN_U16;
 use crate::data::ActualListing;
-use crate::features::property_level_feature_names;
+use crate::licensing::{check_license_bounds, resolve_share_code};
 use crate::parsing::{
     parse_filters_with_poi, require_bounds, row_passes_filters, row_passes_poi_filters,
+    ParsedEnumFilter, ParsedFilter,
 };
 use crate::state::{AppState, SharedState};
 
@@ -25,6 +29,8 @@ pub struct ActualListingsParams {
     travel: Option<String>,
     /// Number of results to skip. Defaults to 0.
     offset: Option<usize>,
+    /// Share-link code; grants bbox-scoped access for unlicensed users.
+    share: Option<String>,
 }
 
 #[derive(Serialize)]
@@ -35,10 +41,24 @@ pub struct ActualListingsResponse {
     pub truncated: bool,
 }
 
+const LISTING_LEVEL_FILTER_FEATURES: &[&str] = &[
+    "Property type",
+    "Leasehold/Freehold",
+    "Total floor area (sqm)",
+    "Number of bedrooms & living rooms",
+    "Estimated current price",
+    "Last known price",
+    "Est. price per sqm",
+    "Price per sqm",
+];
+
+const KEEP_UNKNOWN_LISTING_FILTER_FEATURES: &[&str] = &["Total floor area (sqm)"];
+
 pub async fn get_actual_listings(
     State(shared): State<Arc<SharedState>>,
+    Extension(user): Extension<OptionalUser>,
     Query(params): Query<ActualListingsParams>,
-) -> Result<Json<ActualListingsResponse>, ApiError> {
+) -> Result<Json<ActualListingsResponse>, Response> {
     let state = shared.load_state();
     let offset = params.offset.unwrap_or(0);
     let Some(actual_listings) = state.actual_listings.clone() else {
@@ -49,11 +69,15 @@ pub async fn get_actual_listings(
             truncated: false,
         }));
     };
-    let (south, west, north, east) = require_bounds(params.bounds).map_err(ApiError::from)?;
+    let (south, west, north, east) =
+        require_bounds(params.bounds).map_err(IntoResponse::into_response)?;
+
+    let share_bounds = resolve_share_code(&state, params.share.as_deref()).await;
+    check_license_bounds(&user.0, (south, west, north, east), share_bounds)?;
 
     let quant = state.data.quant_ref();
     let poi_quant = state.data.poi_metrics.quant_ref();
-    let (mut parsed_filters, mut parsed_enum_filters, parsed_poi_filters) = parse_filters_with_poi(
+    let (parsed_filters, parsed_enum_filters, parsed_poi_filters) = parse_filters_with_poi(
         params.filters.as_deref(),
         &state.feature_name_to_index,
         &state.data.enum_values,
@@ -61,40 +85,38 @@ pub async fn get_actual_listings(
         &state.data.poi_metrics.name_to_index,
         &poi_quant,
     )
-    .map_err(ApiError::BadRequest)?;
+    .map_err(|err| ApiError::BadRequest(err).into_response())?;
 
-    // Drop property-level filters (price, sqm, build year, beds, type, etc.) so they
-    // don't hide live listings — those are individual-property concerns the user can
-    // judge from the pin itself. We only keep area/postcode-level filters here.
-    let property_level_idxs: FxHashSet<usize> = property_level_feature_names()
-        .into_iter()
-        .filter_map(|name| state.feature_name_to_index.get(name).copied())
-        .collect();
-    parsed_filters.retain(|f| !property_level_idxs.contains(&f.feat_idx));
-    parsed_enum_filters.retain(|f| !property_level_idxs.contains(&f.feat_idx));
+    let travel_entries = parse_optional_travel(params.travel.as_deref())
+        .map_err(|err| ApiError::BadRequest(err).into_response())?;
 
-    let travel_entries =
-        parse_optional_travel(params.travel.as_deref()).map_err(ApiError::BadRequest)?;
+    let listing_level_feature_idxs = listing_level_filter_feature_idxs(&state);
+    let keep_unknown_listing_filter_idxs = keep_unknown_listing_filter_feature_idxs(&state);
+    let (listing_filters, postcode_filters) =
+        split_numeric_filters(parsed_filters, &listing_level_feature_idxs);
+    let (listing_enum_filters, postcode_enum_filters) =
+        split_enum_filters(parsed_enum_filters, &listing_level_feature_idxs);
 
-    let has_area_filters = !parsed_filters.is_empty()
-        || !parsed_enum_filters.is_empty()
+    let has_postcode_filters = !postcode_filters.is_empty()
+        || !postcode_enum_filters.is_empty()
         || !parsed_poi_filters.is_empty()
         || !travel_entries.is_empty();
+    let has_listing_filters = !listing_filters.is_empty() || !listing_enum_filters.is_empty();
 
     let state_clone = state.clone();
     let response =
         tokio::task::spawn_blocking(move || -> Result<ActualListingsResponse, String> {
             let t0 = std::time::Instant::now();
 
-            let passing_postcodes = if has_area_filters {
+            let passing_postcodes = if has_postcode_filters {
                 Some(compute_passing_postcodes(
                     &state_clone,
                     south,
                     west,
                     north,
                     east,
-                    &parsed_filters,
-                    &parsed_enum_filters,
+                    &postcode_filters,
+                    &postcode_enum_filters,
                     &parsed_poi_filters,
                     &travel_entries,
                 )?)
@@ -116,6 +138,18 @@ pub async fn get_actual_listings(
                             return None;
                         }
                     }
+                    if has_listing_filters
+                        && !row_passes_listing_filters(
+                            row,
+                            &listing_filters,
+                            &listing_enum_filters,
+                            &actual_listings.filter_feature_data,
+                            state_clone.data.num_features,
+                            &keep_unknown_listing_filter_idxs,
+                        )
+                    {
+                        return None;
+                    }
                     Some(row)
                 })
                 .collect();
@@ -142,7 +176,8 @@ pub async fn get_actual_listings(
                 total = total_matching,
                 total_in_bounds,
                 offset,
-                filtered = passing_postcodes.is_some(),
+                postcode_filtered = passing_postcodes.is_some(),
+                listing_filtered = has_listing_filters,
                 ms = format_args!("{:.1}", elapsed.as_secs_f64() * 1000.0),
                 "GET /api/actual-listings"
             );
@@ -155,12 +190,82 @@ pub async fn get_actual_listings(
             })
         })
         .await
-        .map_err(|error| ApiError::Internal(error.to_string()))?
-        .map_err(ApiError::Internal)?;
+        .map_err(|error| ApiError::Internal(error.to_string()).into_response())?
+        .map_err(|err| ApiError::Internal(err).into_response())?;
 
     Ok(Json(response))
 }
 
+fn listing_level_filter_feature_idxs(state: &AppState) -> FxHashSet<usize> {
+    feature_idxs(state, LISTING_LEVEL_FILTER_FEATURES)
+}
+
+fn keep_unknown_listing_filter_feature_idxs(state: &AppState) -> FxHashSet<usize> {
+    feature_idxs(state, KEEP_UNKNOWN_LISTING_FILTER_FEATURES)
+}
+
+fn feature_idxs(state: &AppState, names: &[&str]) -> FxHashSet<usize> {
+    names
+        .iter()
+        .filter_map(|name| state.feature_name_to_index.get(*name).copied())
+        .collect()
+}
+
+fn split_numeric_filters(
+    filters: Vec<ParsedFilter>,
+    listing_level_feature_idxs: &FxHashSet<usize>,
+) -> (Vec<ParsedFilter>, Vec<ParsedFilter>) {
+    let mut listing_filters = Vec::new();
+    let mut postcode_filters = Vec::new();
+    for filter in filters {
+        if listing_level_feature_idxs.contains(&filter.feat_idx) {
+            listing_filters.push(filter);
+        } else {
+            postcode_filters.push(filter);
+        }
+    }
+    (listing_filters, postcode_filters)
+}
+
+fn split_enum_filters(
+    filters: Vec<ParsedEnumFilter>,
+    listing_level_feature_idxs: &FxHashSet<usize>,
+) -> (Vec<ParsedEnumFilter>, Vec<ParsedEnumFilter>) {
+    let mut listing_filters = Vec::new();
+    let mut postcode_filters = Vec::new();
+    for filter in filters {
+        if listing_level_feature_idxs.contains(&filter.feat_idx) {
+            listing_filters.push(filter);
+        } else {
+            postcode_filters.push(filter);
+        }
+    }
+    (listing_filters, postcode_filters)
+}
+
+fn row_passes_listing_filters(
+    row: usize,
+    filters: &[ParsedFilter],
+    enum_filters: &[ParsedEnumFilter],
+    feature_data: &[u16],
+    num_features: usize,
+    keep_unknown_filter_idxs: &FxHashSet<usize>,
+) -> bool {
+    let base = row * num_features;
+
+    filters.iter().all(|filter| {
+        let raw = feature_data[base + filter.feat_idx];
+        if raw == NAN_U16 {
+            keep_unknown_filter_idxs.contains(&filter.feat_idx)
+        } else {
+            raw >= filter.min_u16 && raw <= filter.max_u16
+        }
+    }) && enum_filters.iter().all(|filter| {
+        let raw = feature_data[base + filter.feat_idx];
+        raw != NAN_U16 && filter.allowed.contains(&raw)
+    })
+}
+
 #[allow(clippy::too_many_arguments)]
 fn compute_passing_postcodes(
     state: &AppState,
@@ -224,3 +329,111 @@ fn compute_passing_postcodes(
 
     Ok(passing)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn numeric_filter(feat_idx: usize) -> ParsedFilter {
+        ParsedFilter {
+            feat_idx,
+            min_u16: 0,
+            max_u16: 100,
+        }
+    }
+
+    fn enum_filter(feat_idx: usize) -> ParsedEnumFilter {
+        ParsedEnumFilter {
+            feat_idx,
+            allowed: [0u16].into_iter().collect(),
+        }
+    }
+
+    #[test]
+    fn splits_actual_listing_filters_by_listing_native_features() {
+        let listing_level_feature_idxs: FxHashSet<usize> = [1usize, 3].into_iter().collect();
+
+        let (listing_filters, postcode_filters) = split_numeric_filters(
+            vec![numeric_filter(0), numeric_filter(1), numeric_filter(3)],
+            &listing_level_feature_idxs,
+        );
+        assert_eq!(
+            listing_filters
+                .iter()
+                .map(|filter| filter.feat_idx)
+                .collect::<Vec<_>>(),
+            vec![1, 3]
+        );
+        assert_eq!(
+            postcode_filters
+                .iter()
+                .map(|filter| filter.feat_idx)
+                .collect::<Vec<_>>(),
+            vec![0]
+        );
+
+        let (listing_enum_filters, postcode_enum_filters) = split_enum_filters(
+            vec![enum_filter(2), enum_filter(3)],
+            &listing_level_feature_idxs,
+        );
+        assert_eq!(
+            listing_enum_filters
+                .iter()
+                .map(|filter| filter.feat_idx)
+                .collect::<Vec<_>>(),
+            vec![3]
+        );
+        assert_eq!(
+            postcode_enum_filters
+                .iter()
+                .map(|filter| filter.feat_idx)
+                .collect::<Vec<_>>(),
+            vec![2]
+        );
+    }
+
+    #[test]
+    fn listing_floor_area_filter_keeps_unknown_values() {
+        let floor_area_filter = ParsedFilter {
+            feat_idx: 0,
+            min_u16: 10,
+            max_u16: 20,
+        };
+        let keep_unknown_filter_idxs: FxHashSet<usize> = [0usize].into_iter().collect();
+
+        assert!(row_passes_listing_filters(
+            0,
+            &[floor_area_filter],
+            &[],
+            &[NAN_U16],
+            1,
+            &keep_unknown_filter_idxs
+        ));
+
+        assert!(!row_passes_listing_filters(
+            0,
+            &[ParsedFilter {
+                feat_idx: 0,
+                min_u16: 10,
+                max_u16: 20,
+            }],
+            &[],
+            &[9],
+            1,
+            &keep_unknown_filter_idxs
+        ));
+
+        assert!(row_passes_listing_filters(
+            0,
+            &[ParsedFilter {
+                feat_idx: 0,
+                min_u16: 10,
+                max_u16: 20,
+            }],
+            &[],
+            &[15],
+            1,
+            &keep_unknown_filter_idxs
+        ));
+    }
+}