105 lines
2.6 KiB
Rust
105 lines
2.6 KiB
Rust
use fathom_function::tracing;
|
|
use pipeline_application::application::{
|
|
AnomalySizeSetting, Application, ClusteringConfig, Interaction as ClusteringInteraction,
|
|
SurfaceLocationSensitivity,
|
|
};
|
|
use serde::{Deserialize, Serialize};
|
|
use uuid::Uuid;
|
|
|
|
#[fathom_function::function]
|
|
async fn ili_clustering_all(input: Input) -> Result<Output, String> {
|
|
let app = Application::new_from_compile_env(input.org_id, input.project_id).unwrap();
|
|
|
|
for (pipeline_id, ili_id) in input.pipeline_id.into_iter().zip(input.ili_id) {
|
|
app.ili_clustering_all_rules(pipeline_id, ili_id, &input.config)
|
|
.await
|
|
.map_err(|err| {
|
|
tracing::error!(%pipeline_id, %ili_id, ?err, "Error running clustering algorithm");
|
|
format!("{err:?}")
|
|
})?;
|
|
}
|
|
|
|
Ok(Output {
|
|
status: "Success".to_owned(),
|
|
})
|
|
}
|
|
|
|
#[derive(Debug, Serialize)]
|
|
struct Output {
|
|
status: String,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy, Deserialize)]
|
|
#[serde(rename_all = "snake_case")]
|
|
enum SizeSettings {
|
|
Original,
|
|
Tolerance,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy, Deserialize)]
|
|
#[serde(rename_all = "snake_case")]
|
|
pub enum Interaction {
|
|
Enabled,
|
|
Disabled,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy, Deserialize)]
|
|
#[serde(rename_all = "snake_case")]
|
|
pub enum SurfaceLocation {
|
|
Matching,
|
|
Any,
|
|
}
|
|
|
|
#[derive(Debug, Deserialize)]
|
|
struct Input {
|
|
org_id: Uuid,
|
|
project_id: String,
|
|
pipeline_id: Vec<Uuid>,
|
|
ili_id: Vec<Uuid>,
|
|
#[serde(flatten)]
|
|
config: Config,
|
|
}
|
|
|
|
#[derive(Debug, Deserialize)]
|
|
struct Config {
|
|
size_settings: SizeSettings,
|
|
interaction: Interaction,
|
|
surface_location: SurfaceLocation,
|
|
}
|
|
|
|
impl From<SizeSettings> for AnomalySizeSetting {
|
|
fn from(value: SizeSettings) -> Self {
|
|
match value {
|
|
SizeSettings::Original => Self::Original,
|
|
SizeSettings::Tolerance => Self::WithTolerance,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<SurfaceLocation> for SurfaceLocationSensitivity {
|
|
fn from(value: SurfaceLocation) -> Self {
|
|
match value {
|
|
SurfaceLocation::Matching => Self::Matching,
|
|
SurfaceLocation::Any => Self::Any,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<Interaction> for ClusteringInteraction {
|
|
fn from(value: Interaction) -> Self {
|
|
match value {
|
|
Interaction::Enabled => Self::Enabled,
|
|
Interaction::Disabled => Self::Disabled,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<&Config> for ClusteringConfig {
|
|
fn from(value: &Config) -> Self {
|
|
Self::default()
|
|
.with_interaction(value.interaction.into())
|
|
.with_surface_location(value.surface_location.into())
|
|
.with_size_settings(value.size_settings.into())
|
|
}
|
|
}
|