Automatic push from FunctionsAPI

Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+  edition = "2021"
+  name    = "web"
+  version = "0.1.0"
+
+[dependencies]
+  axum                   = { version = "0.8" }
+  openssl                = { version = "0.10", features = ["vendored"] }
+  pipeline-application   = { git = "ssh://git@github.com/fathom-io/pipeline-calculations.git", branch = "johnabell/ili-validation-load" }
+  pipeline-configuration = { git = "ssh://git@github.com/fathom-io/pipeline-calculations.git", branch = "johnabell/ili-validation-load" }
+  serde                  = { version = "1.0.219", features = ["derive"] }
+  serde_json             = "1.0.138"
+  tokio                  = { version = "1.43.0", features = ["macros", "rt-multi-thread"] }
+  tracing                = { version = "0.1" }
+  tracing-subscriber     = { version = "0.3" }
+  uuid                   = { version = "1" }

src/main.rs

@@ -0,0 +1,143 @@
+use axum::http::HeaderMap;
+use axum::{routing::post, Router};
+use pipeline_application::application::{Application, Env, SegmentationConfiguration};
+use pipeline_configuration::facilities::FacilityType;
+use std::io;
+use std::net::SocketAddr;
+use tokio::net::TcpListener;
+use uuid::Uuid;
+
+async fn segment(headers: HeaderMap, body: String) -> String {
+    let env = std::env::vars().collect::<Vec<_>>();
+    println!("Request headers: {headers:?}, request body: {body}, env: {env:?}");
+
+    let context = Context::from_env().unwrap();
+    let args = Args::from_body(&body).unwrap();
+
+    Application::new(context.env, context.org_id, context.project_id)
+        .unwrap()
+        .segment_all(args)
+        .await
+        .unwrap();
+
+    format!("Request headers: {headers:?}, request body: {body}, env: {env:?}")
+}
+
+struct Context {
+    org_id: Uuid,
+    project_id: String,
+    env: Env,
+}
+
+impl Context {
+    fn from_env() -> io::Result<Self> {
+        let org_id = std::env::var("ORG_ID")
+            .unwrap_or_else(|_| "2cbfe270-d195-48ad-aed1-24145924635c".to_string())
+            .parse()
+            .map_err(io::Error::other)?;
+        let project_id =
+            std::env::var("PROJECT_ID").unwrap_or_else(|_| "67c6f36910e4c56ed42bf841".to_string());
+
+        Ok(Self {
+            org_id,
+            project_id,
+            env: Self::get_env(),
+        })
+    }
+
+    fn get_env() -> Env {
+        match std::env::var("ENV") {
+            Ok(env) if env == "stg" || env == "staging" => Env::Staging,
+            _ => Env::Dev,
+        }
+    }
+}
+
+#[tokio::main]
+async fn main() {
+    init_logger();
+    let router = Router::new().route("/", post(segment));
+
+    let addr = SocketAddr::from(([0, 0, 0, 0], 8080));
+    let tcp = TcpListener::bind(&addr).await.unwrap();
+    println!("Ready and listening on {}", addr);
+    axum::serve(tcp, router).await.unwrap();
+}
+
+fn init_logger() {
+    use tracing::{level_filters::LevelFilter, Level};
+    use tracing_subscriber::{fmt, layer::SubscriberExt};
+    let subscriber = tracing_subscriber::registry()
+        .with(LevelFilter::from_level(Level::INFO))
+        //.with(tracing_subscriber::EnvFilter::from_env("LOG_LEVEL"))
+        .with(
+            fmt::Layer::default()
+                .with_target(true)
+                .with_thread_names(true)
+                .with_thread_ids(true)
+                .with_ansi(true)
+                .with_line_number(true)
+                .with_file(true),
+        );
+
+    tracing::subscriber::set_global_default(subscriber)
+        .expect("Unable to set a global logger instance");
+}
+
+#[derive(Debug, serde::Deserialize)]
+struct Args {
+    facilities: Vec<FacilityType>,
+    local_data: Vec<String>,
+}
+
+impl From<Args> for SegmentationConfiguration {
+    fn from(value: Args) -> Self {
+        let mut config = Self::default_false();
+        for fac in value.facilities {
+            config = match fac {
+                FacilityType::InsulationJoint => config.by_insulation_joints(true),
+                FacilityType::Repair => config.by_repairs(true),
+                FacilityType::Valve => config.by_valves(true),
+                _ => config,
+            };
+        }
+        // TODO: add crossing configuration
+        for loc in value.local_data {
+            config = match loc.as_str() {
+                "material_grade" => config.by_material_grade(true),
+                "coating_type" => config.by_coating_type(true),
+                "design_factor" => config.by_design_factor(true),
+                "high_consequence_area" => config.by_high_consequence_area(true),
+                "unusual_sensitive_area" => config.by_unusual_sensitive_area(true),
+                "joint_type" => config.by_joint_type(true),
+                "soil_type" => config.by_soil_type(true),
+                "soil_ph" => config.by_soil_ph(true),
+                _ => config,
+            }
+        }
+
+        config
+    }
+}
+
+impl Args {
+    fn from_body(body: &str) -> serde_json::Result<Self> {
+        let value: String = serde_json::from_str(body)?;
+        serde_json::from_str(&value)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    const INPUT: &str = "\"{\\\"facilities\\\": [\\\"repair\\\"], \\\"formData\\\": {\\\"facilities\\\": [\\\"repairs\\\"], \\\"localProperties\\\": [\\\"material_grade\\\", \\\"coating_type\\\", \\\"soil_type\\\", \\\"soil_ph\\\"]}, \\\"input\\\": null, \\\"local_data\\\": [\\\"material_grade\\\", \\\"coating_type\\\", \\\"soil_type\\\", \\\"soil_ph\\\"]}\"";
+
+    #[test]
+    fn test() {
+        let env = std::env::vars().collect::<Vec<_>>();
+
+        println!("body: {}, env: {env:?}", INPUT);
+        let args = Args::from_body(INPUT);
+        dbg!(args).unwrap();
+    }
+}