FIxes

server-rs/src/routes/postcode_properties.rs

@@ -0,0 +1,144 @@
+use std::sync::Arc;
+
+use axum::extract::Query;
+use axum::http::StatusCode;
+use axum::response::{IntoResponse, Json};
+use axum::Extension;
+use serde::Deserialize;
+use tracing::{info, warn};
+
+use crate::auth::OptionalUser;
+use crate::consts::{DEFAULT_PROPERTIES_LIMIT, MAX_PROPERTIES_LIMIT, POSTCODE_SEARCH_OFFSET};
+use crate::licensing::check_license_point;
+use crate::parsing::{parse_filters, row_passes_filters};
+use crate::state::AppState;
+
+use super::properties::{HexagonPropertiesResponse, Property};
+
+#[derive(Deserialize)]
+pub struct PostcodePropertiesParams {
+    pub postcode: String,
+    pub filters: Option<String>,
+    pub limit: Option<usize>,
+    pub offset: Option<usize>,
+}
+
+pub async fn get_postcode_properties(
+    state: Arc<AppState>,
+    Extension(user): Extension<OptionalUser>,
+    Query(params): Query<PostcodePropertiesParams>,
+) -> Result<Json<HexagonPropertiesResponse>, axum::response::Response> {
+    let normalized = params
+        .postcode
+        .to_uppercase()
+        .split_whitespace()
+        .collect::<Vec<_>>()
+        .join(" ");
+
+    let pc_idx = match state.postcode_data.postcode_to_idx.get(&normalized) {
+        Some(&idx) => idx,
+        None => {
+            warn!(postcode = %normalized, "Postcode not found");
+            return Err((
+                StatusCode::NOT_FOUND,
+                format!("Postcode not found: {}", normalized),
+            )
+                .into_response());
+        }
+    };
+    let (centroid_lat, centroid_lon) = state.postcode_data.centroids[pc_idx];
+
+    check_license_point(&user.0, centroid_lat as f64, centroid_lon as f64)
+        .map_err(|(_, resp)| resp)?;
+
+    let filters_str = params.filters.clone();
+    let (parsed_filters, parsed_enum_filters) = parse_filters(
+        params.filters.as_deref(),
+        &state.feature_name_to_index,
+        &state.data.enum_values,
+    )
+    .map_err(|err| (StatusCode::BAD_REQUEST, err).into_response())?;
+    let num_filters = parsed_filters.len() + parsed_enum_filters.len();
+
+    let postcode_str = normalized.clone();
+
+    let result = tokio::task::spawn_blocking(move || {
+        let t0 = std::time::Instant::now();
+        let num_features = state.data.num_features;
+        let feature_data = &state.data.feature_data;
+        let feature_names = &state.data.feature_names;
+        let feature_name_to_index = &state.feature_name_to_index;
+        let enum_values = &state.data.enum_values;
+
+        let offset_deg: f64 = POSTCODE_SEARCH_OFFSET;
+        let min_lat = centroid_lat as f64 - offset_deg;
+        let max_lat = centroid_lat as f64 + offset_deg;
+        let min_lon = centroid_lon as f64 - offset_deg;
+        let max_lon = centroid_lon as f64 + offset_deg;
+
+        let mut matching_rows: Vec<usize> = Vec::new();
+        state
+            .grid
+            .for_each_in_bounds(min_lat, min_lon, max_lat, max_lon, |row_idx| {
+                let row = row_idx as usize;
+                if state.data.postcode(row) == postcode_str
+                    && row_passes_filters(
+                        row,
+                        &parsed_filters,
+                        &parsed_enum_filters,
+                        feature_data,
+                        num_features,
+                    )
+                {
+                    matching_rows.push(row);
+                }
+            });
+
+        matching_rows.sort_unstable_by_key(|&row| state.data.address(row).trim().is_empty());
+
+        let total = matching_rows.len();
+        let limit = params
+            .limit
+            .unwrap_or(DEFAULT_PROPERTIES_LIMIT)
+            .min(MAX_PROPERTIES_LIMIT);
+        let page_offset = params.offset.unwrap_or(0);
+        let truncated = total > page_offset + limit;
+
+        let properties: Vec<Property> = matching_rows
+            .iter()
+            .skip(page_offset)
+            .take(limit)
+            .map(|&row| {
+                super::properties::build_property(
+                    row, &state, feature_names, feature_name_to_index, feature_data,
+                    num_features, enum_values,
+                )
+            })
+            .collect();
+
+        let elapsed = t0.elapsed();
+        info!(
+            postcode = %postcode_str,
+            total,
+            returned = properties.len(),
+            offset = page_offset,
+            filters = num_filters,
+            filters_raw = filters_str.as_deref().unwrap_or("-"),
+            ms = format_args!("{:.1}", elapsed.as_secs_f64() * 1000.0),
+            "GET /api/postcode-properties"
+        );
+
+        Ok(HexagonPropertiesResponse {
+            properties,
+            total,
+            limit,
+            offset: page_offset,
+            truncated,
+        })
+    })
+    .await
+    .map_err(|error| (StatusCode::INTERNAL_SERVER_ERROR, error.to_string()).into_response())?
+    .map_err(|error: String| (StatusCode::INTERNAL_SERVER_ERROR, error).into_response())?;
+
+    Ok(Json(result))
+}