587 lines
22 KiB
Rust
587 lines
22 KiB
Rust
use crate::{error_handler::ServiceError, db};
|
|
use crate::db::schema::metars::{self};
|
|
use chrono::Datelike;
|
|
use diesel::{prelude::*, sql_query};
|
|
use log::{warn, trace};
|
|
use std::collections::HashSet;
|
|
use serde::{Deserialize, Serialize};
|
|
|
|
#[derive(Serialize, Deserialize, Debug)]
|
|
pub struct QualityControlFlags {
|
|
pub auto: Option<bool>,
|
|
pub auto_station_without_precipication: Option<bool>,
|
|
pub auto_station_with_precipication: Option<bool>,
|
|
pub maintenance_indicator_on: Option<bool>,
|
|
pub corrected: Option<bool>
|
|
}
|
|
|
|
impl Default for QualityControlFlags {
|
|
fn default() -> Self {
|
|
QualityControlFlags {
|
|
auto: None,
|
|
auto_station_without_precipication: None,
|
|
auto_station_with_precipication: None,
|
|
maintenance_indicator_on: None,
|
|
corrected: None,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Serialize, Deserialize, Debug)]
|
|
pub struct SkyCondition {
|
|
pub sky_cover: String,
|
|
pub cloud_base_ft_agl: Option<i32>
|
|
}
|
|
|
|
impl Default for SkyCondition {
|
|
fn default() -> Self {
|
|
SkyCondition {
|
|
sky_cover: "".to_string(),
|
|
cloud_base_ft_agl: None
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Serialize, Deserialize, Debug)]
|
|
pub struct RunwayVisualRange {
|
|
pub runway: String,
|
|
pub visibility_ft: Option<String>,
|
|
pub variable_visibility_high_ft: Option<String>,
|
|
pub variable_visibility_low_ft: Option<String>
|
|
}
|
|
|
|
impl Default for RunwayVisualRange {
|
|
fn default() -> Self {
|
|
RunwayVisualRange {
|
|
runway: "".to_string(),
|
|
visibility_ft: None,
|
|
variable_visibility_high_ft: None,
|
|
variable_visibility_low_ft: None
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Serialize, Deserialize, Debug)]
|
|
pub enum FlightCategory {
|
|
VFR,
|
|
MVFR,
|
|
LIFR,
|
|
IFR,
|
|
UNKN
|
|
}
|
|
|
|
#[derive(Serialize, Deserialize, Debug)]
|
|
pub struct Metar {
|
|
pub raw_text: String,
|
|
pub station_id: String,
|
|
pub observation_time: chrono::NaiveDateTime,
|
|
pub temp_c: Option<f64>,
|
|
pub dewpoint_c: Option<f64>,
|
|
pub wind_dir_degrees: Option<String>,
|
|
pub wind_speed_kt: Option<i32>,
|
|
pub wind_gust_kt: Option<i32>,
|
|
pub variable_wind_dir_degrees: Option<String>,
|
|
pub visibility_statute_mi: Option<String>,
|
|
pub runway_visual_range: Vec<RunwayVisualRange>,
|
|
pub altim_in_hg: Option<f64>,
|
|
pub sea_level_pressure_mb: Option<f64>,
|
|
pub quality_control_flags: QualityControlFlags,
|
|
pub weather_phenomena: Vec<String>,
|
|
pub sky_condition: Vec<SkyCondition>,
|
|
pub flight_category: FlightCategory,
|
|
pub three_hr_pressure_tendency_mb: Option<f64>,
|
|
pub max_t_c: Option<f64>,
|
|
pub min_t_c: Option<f64>,
|
|
pub precip_in: Option<f64>,
|
|
}
|
|
|
|
impl Default for Metar {
|
|
fn default() -> Self {
|
|
Metar {
|
|
raw_text: "".to_string(),
|
|
station_id: "".to_string(),
|
|
observation_time: chrono::NaiveDateTime::parse_from_str("1970-01-01T00:00:00", "%Y-%m-%dT%H:%M:%S").unwrap(),
|
|
temp_c: None,
|
|
dewpoint_c: None,
|
|
wind_dir_degrees: None,
|
|
wind_speed_kt: None,
|
|
wind_gust_kt: None,
|
|
variable_wind_dir_degrees: None,
|
|
visibility_statute_mi: None,
|
|
runway_visual_range: vec![],
|
|
altim_in_hg: None,
|
|
sea_level_pressure_mb: None,
|
|
quality_control_flags: QualityControlFlags::default(),
|
|
weather_phenomena: vec![],
|
|
sky_condition: vec![],
|
|
flight_category: FlightCategory::UNKN,
|
|
three_hr_pressure_tendency_mb: None,
|
|
max_t_c: None,
|
|
min_t_c: None,
|
|
precip_in: None,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Metar {
|
|
fn parse(metar_strings: Vec<&str>) -> Result<Vec<Self>, ServiceError> {
|
|
let mut metars: Vec<Self> = vec![];
|
|
for metar_string in metar_strings {
|
|
trace!("Parsing METAR data: {}", metar_string);
|
|
let mut metar: Metar = Metar::default();
|
|
metar.raw_text = metar_string.to_owned();
|
|
let mut metar_parts: Vec<&str> = metar_string.split_whitespace().collect();
|
|
if metar_parts.len() < 4 {
|
|
warn!("Unable to parse METAR data in an unexpected format: {}", metar_string);
|
|
continue;
|
|
}
|
|
|
|
// Station Identifier
|
|
metar.station_id = metar_parts[0].to_string();
|
|
metar_parts.remove(0);
|
|
|
|
// Date/Time
|
|
let observation_time = metar_parts[0];
|
|
metar_parts.remove(0);
|
|
let observation_time_day = &observation_time[0..2];
|
|
let observation_time_hour = &observation_time[2..4];
|
|
let observation_time_minute = &observation_time[4..6];
|
|
let current_time = chrono::Utc::now().naive_utc();
|
|
// Check if the observation time is from the previous month
|
|
let observation_time_month = if current_time.day() > observation_time_day.parse::<u32>().unwrap() {
|
|
current_time.month() - 1
|
|
} else {
|
|
current_time.month()
|
|
};
|
|
// Check if the observation time is from the previous year
|
|
let observation_time_year = if current_time.month() > observation_time_month {
|
|
current_time.year() - 1
|
|
} else {
|
|
current_time.year()
|
|
};
|
|
// Handle Daylight Savings Time
|
|
let observation_time_hour = if observation_time_month == 3 && observation_time_day.parse::<u32>().unwrap() < 14 {
|
|
observation_time_hour.parse::<u32>().unwrap() - 1
|
|
} else {
|
|
observation_time_hour.parse::<u32>().unwrap()
|
|
};
|
|
let observation_time = format!("{}-{}-{}T{}:{}:00Z", observation_time_year, observation_time_month, observation_time_day, observation_time_hour, observation_time_minute);
|
|
metar.observation_time = chrono::NaiveDateTime::parse_from_str(&observation_time, "%Y-%m-%dT%H:%M:%SZ").unwrap();
|
|
|
|
loop {
|
|
if metar_parts.is_empty() {
|
|
break;
|
|
}
|
|
// Report Modifiers
|
|
if metar_parts[0] == "AUTO" {
|
|
metar.quality_control_flags.auto = Some(true);
|
|
metar_parts.remove(0);
|
|
} else if metar_parts[0] == "COR" {
|
|
metar.quality_control_flags.corrected = Some(true);
|
|
metar_parts.remove(0);
|
|
}
|
|
|
|
// Wind Direction and Speed
|
|
let wind_re = regex::Regex::new(r"^(?:[0-9]{3}|VRB)[0-9]{2}KT$").unwrap();
|
|
let wind_gust_re = regex::Regex::new(r"^(?:[0-9]{3}|VRB)[0-9]{2}G[0-9]{2}KT$").unwrap();
|
|
if wind_re.is_match(metar_parts[0]) {
|
|
let wind = metar_parts[0];
|
|
metar_parts.remove(0);
|
|
let wind_dir_degrees = &wind[0..3];
|
|
let wind_speed_kt = &wind[3..5];
|
|
metar.wind_dir_degrees = Some(wind_dir_degrees.to_string());
|
|
metar.wind_speed_kt = Some(wind_speed_kt.parse::<i32>().unwrap());
|
|
} else if wind_gust_re.is_match(metar_parts[0]) {
|
|
let wind = metar_parts[0];
|
|
metar_parts.remove(0);
|
|
let wind_dir_degrees = &wind[0..3];
|
|
let wind_speed_kt = &wind[3..5];
|
|
metar.wind_dir_degrees = Some(wind_dir_degrees.to_string());
|
|
metar.wind_speed_kt = Some(wind_speed_kt.parse::<i32>().unwrap());
|
|
// Gust
|
|
let wind_gust_kt = &wind[6..8];
|
|
metar.wind_gust_kt = Some(wind_gust_kt.parse::<i32>().unwrap());
|
|
}
|
|
|
|
// Variable Wind Direction
|
|
let variable_wind_re = regex::Regex::new(r"^[0-9]{3}V[0-9]{3}$").unwrap();
|
|
if variable_wind_re.is_match(metar_parts[0]) {
|
|
metar.variable_wind_dir_degrees = Some(metar_parts[0].to_string());
|
|
metar_parts.remove(0);
|
|
}
|
|
|
|
// Visibility
|
|
let visibility_re = regex::Regex::new(r"^M?(?:[0-9]+|[0-9]+/[0-9]+)SM").unwrap();
|
|
if visibility_re.is_match(metar_parts[0]) {
|
|
let visibility_str = &metar_parts[0][0..metar_parts[0].len() - 2];
|
|
metar_parts.remove(0);
|
|
let visibility: String = if visibility_str.contains("/") {
|
|
let visibility_parts: Vec<&str> = visibility_str.split("/").collect();
|
|
let visibility_left = visibility_parts[0];
|
|
let visibility_right = visibility_parts[1].parse::<f64>().unwrap();
|
|
if visibility_left.starts_with("M") {
|
|
format!("M{}", visibility_left[1..visibility_left.len()].parse::<f64>().unwrap() / visibility_right)
|
|
} else if visibility_left.starts_with("P") {
|
|
format!("P{}", visibility_left[1..visibility_left.len()].parse::<f64>().unwrap() / visibility_right)
|
|
} else {
|
|
format!("{}", visibility_left.parse::<f64>().unwrap() / visibility_right)
|
|
}
|
|
} else {
|
|
visibility_str.to_string()
|
|
};
|
|
metar.visibility_statute_mi = Some(visibility);
|
|
} else if metar_parts[0].parse::<f64>().is_ok() && metar_parts.len() > 1 && visibility_re.is_match(metar_parts[1]) {
|
|
let visibility_whole = metar_parts[0].parse::<f64>().unwrap();
|
|
metar_parts.remove(0);
|
|
let visibility_parts: Vec<&str> = metar_parts[0].split("/").collect();
|
|
metar_parts.remove(0);
|
|
let visibility_left = visibility_parts[0];
|
|
let visibility_right = visibility_parts[1][0..visibility_parts[1].len() - 2].parse::<f64>().unwrap();
|
|
let visibility = if visibility_left.starts_with("M") {
|
|
format!("M{}", visibility_whole + (visibility_left[1..visibility_left.len()].parse::<f64>().unwrap() / visibility_right))
|
|
} else if visibility_left.starts_with("P") {
|
|
format!("P{}", visibility_whole + (visibility_left[1..visibility_left.len()].parse::<f64>().unwrap() / visibility_right))
|
|
} else {
|
|
format!("{}", visibility_whole + (visibility_left.parse::<f64>().unwrap() / visibility_right))
|
|
};
|
|
metar.visibility_statute_mi = Some(visibility);
|
|
}
|
|
|
|
// Runway Visual Range
|
|
let rvr_re = regex::Regex::new(r"^R[0-9]{1,3}(?:L|R|C)?/[PM]?[0-9]{4}FT$").unwrap();
|
|
let variable_rvr_re = regex::Regex::new(r"^R[0-9]{1,3}(?:L|R|C)?/[PM]?[0-9]{4}V[PM]?[0-9]{4}FT$").unwrap();
|
|
while rvr_re.is_match(metar_parts[0]) || variable_rvr_re.is_match(metar_parts[0]) {
|
|
let rvr_string = metar_parts[0];
|
|
metar_parts.remove(0);
|
|
let mut rvr = RunwayVisualRange::default();
|
|
let rvr_parts: Vec<&str> = rvr_string.split("/").collect();
|
|
rvr.runway = rvr_parts[0].to_string();
|
|
if rvr_re.is_match(rvr_string) {
|
|
rvr.visibility_ft = Some(rvr_parts[1].to_string());
|
|
} else {
|
|
let rvr_variable_parts: Vec<&str> = rvr_parts[1].split("V").collect();
|
|
if rvr_variable_parts.len() != 2 {
|
|
warn!("Unable to parse runway visual range in {}: {}", rvr_string, metar_string);
|
|
} else {
|
|
rvr.variable_visibility_low_ft = Some(rvr_variable_parts[0].to_string());
|
|
rvr.variable_visibility_high_ft = Some(rvr_variable_parts[1].to_string());
|
|
}
|
|
}
|
|
}
|
|
|
|
// Weather Phenomena
|
|
let wx_re = regex::Regex::new(r"^(?:[+-]|VC|MI|PR|BC|DR|BL|SH|TS|FZ)?(?:DZ|RA|SN|SG|IC|PL|GR|GS|UP|BR|FG|FU|VA|DU|SA|HZ|PY|PO|SQ|FC|SS|DS)$").unwrap();
|
|
while wx_re.is_match(metar_parts[0]) {
|
|
metar.weather_phenomena.push(metar_parts[0].to_string());
|
|
metar_parts.remove(0);
|
|
}
|
|
|
|
// Sky Condition
|
|
let sky_condition_re = regex::Regex::new(r"^(?:CLR|SKC|(?:FEW|SCT|BKN|OVC|VV)([0-9]{3})?)$").unwrap();
|
|
while sky_condition_re.is_match(metar_parts[0]) {
|
|
let sky_condition_string = metar_parts[0];
|
|
metar_parts.remove(0);
|
|
let mut sky_condition = SkyCondition::default();
|
|
let sky_cover = &sky_condition_string[0..3];
|
|
sky_condition.sky_cover = sky_cover.to_string();
|
|
if sky_condition_string.len() > 3 {
|
|
sky_condition.cloud_base_ft_agl = Some(sky_condition_string[3..sky_condition_string.len()].parse::<i32>().unwrap() * 100);
|
|
}
|
|
metar.sky_condition.push(sky_condition);
|
|
}
|
|
|
|
// Temperature and Dewpoint
|
|
let temp_re = regex::Regex::new(r"^(?:M?[0-9]{2})?/(?:M?[0-9]{2})?$").unwrap();
|
|
if temp_re.is_match(metar_parts[0]) {
|
|
let temp_string = metar_parts[0];
|
|
metar_parts.remove(0);
|
|
let temp_parts: Vec<&str> = temp_string.split("/").collect();
|
|
let mut temp_c = "";
|
|
let mut dewpoint_c = "";
|
|
if temp_parts.len() != 2 {
|
|
if temp_string.ends_with("/") {
|
|
temp_c = temp_parts[0];
|
|
} else {
|
|
dewpoint_c = temp_parts[0];
|
|
}
|
|
} else {
|
|
temp_c = temp_parts[0];
|
|
dewpoint_c = temp_parts[1];
|
|
}
|
|
if temp_c.starts_with("M") {
|
|
metar.temp_c = Some(temp_c[1..temp_c.len()].parse::<f64>().unwrap() * -1.0);
|
|
} else if !temp_c.is_empty() {
|
|
metar.temp_c = match temp_c.parse::<f64>() {
|
|
Ok(t) => Some(t),
|
|
Err(err) => {
|
|
warn!("Unable to parse temperature in {}: {}", temp_c, err);
|
|
None
|
|
}
|
|
};
|
|
}
|
|
if dewpoint_c.starts_with("M") {
|
|
metar.dewpoint_c = Some(dewpoint_c[1..dewpoint_c.len()].parse::<f64>().unwrap() * -1.0);
|
|
} else if !dewpoint_c.is_empty() {
|
|
metar.dewpoint_c = match dewpoint_c.parse::<f64>() {
|
|
Ok(d) => Some(d),
|
|
Err(err) => {
|
|
warn!("Unable to parse dewpoint in {}: {}", dewpoint_c, err);
|
|
None
|
|
}
|
|
};
|
|
}
|
|
}
|
|
|
|
// Altimeter
|
|
let altim_re = regex::Regex::new(r"^A[0-9]{4}$").unwrap();
|
|
if altim_re.is_match(metar_parts[0]) {
|
|
let altim = metar_parts[0];
|
|
metar_parts.remove(0);
|
|
metar.altim_in_hg = Some(altim[1..altim.len()].parse::<f64>().unwrap() / 100.0);
|
|
}
|
|
|
|
// Remarks
|
|
if !metar_parts.is_empty() && metar_parts[0] == "RMK" {
|
|
metar_parts.remove(0);
|
|
loop {
|
|
if metar_parts.is_empty() {
|
|
break;
|
|
}
|
|
let slp_re = regex::Regex::new(r"^SLP([0-9]{3})$").unwrap();
|
|
let hourly_temp_re = regex::Regex::new(r"^T[01][0-9]{3}[01][0-9]{3}$").unwrap();
|
|
let remark = metar_parts[0];
|
|
metar_parts.remove(0);
|
|
if remark == "AO1" {
|
|
metar.quality_control_flags.auto_station_without_precipication = Some(true);
|
|
} else if remark == "AO2" {
|
|
metar.quality_control_flags.auto_station_with_precipication = Some(true);
|
|
} else if remark == "$" {
|
|
metar.quality_control_flags.maintenance_indicator_on = Some(true);
|
|
} else if slp_re.is_match(remark) {
|
|
let slp = slp_re.captures(remark).unwrap();
|
|
let sea_level_pressure = slp[1].parse::<f64>().unwrap();
|
|
if sea_level_pressure > 500.0 {
|
|
metar.sea_level_pressure_mb = Some((sea_level_pressure / 10.0) + 900.0);
|
|
} else {
|
|
metar.sea_level_pressure_mb = Some((sea_level_pressure / 10.0) + 1000.0);
|
|
}
|
|
} else if hourly_temp_re.is_match(remark) {
|
|
let temp_negation = &remark[1..2];
|
|
let temp = &remark[2..5];
|
|
if let Ok(t) = temp.parse::<f64>() {
|
|
if temp_negation == "0" {
|
|
metar.temp_c = Some(t / 10.0);
|
|
} else {
|
|
metar.temp_c = Some(t / 10.0 * -1.0);
|
|
}
|
|
}
|
|
let dewpoint_negation = &remark[6..7];
|
|
let dewpoint = &remark[6..9];
|
|
if let Ok(d) = dewpoint.parse::<f64>() {
|
|
if dewpoint_negation == "0" {
|
|
metar.dewpoint_c = Some(d / 10.0);
|
|
} else {
|
|
metar.dewpoint_c = Some(d / 10.0 * -1.0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Skip unexpected fields
|
|
if !metar_parts.is_empty() {
|
|
warn!("Skipping unexpected field: '{}' ({})", metar_parts[0], metar_string);
|
|
metar_parts.remove(0);
|
|
}
|
|
}
|
|
|
|
// Flight Category
|
|
if metar.visibility_statute_mi.is_none() || metar.sky_condition.is_empty() {
|
|
metar.flight_category = FlightCategory::UNKN;
|
|
} else {
|
|
let visibility = match &metar.visibility_statute_mi {
|
|
Some(v) => {
|
|
if v.starts_with("M") || v.starts_with("P") {
|
|
v[1..v.len()].parse::<f64>().unwrap()
|
|
} else {
|
|
v.parse::<f64>().unwrap()
|
|
}
|
|
}
|
|
None => 0.0
|
|
};
|
|
let ceiling = match metar.sky_condition.first() {
|
|
Some(s) => {
|
|
if s.sky_cover == "CLR" || s.sky_cover == "SKC" {
|
|
3000.0
|
|
} else if s.sky_cover == "VV" {
|
|
0.0
|
|
} else {
|
|
match s.cloud_base_ft_agl {
|
|
Some(c) => c as f64,
|
|
None => 0.0
|
|
}
|
|
}
|
|
},
|
|
None => 3000.0 // Assume VFR if no sky condition is present
|
|
};
|
|
if visibility >= 5.0 && ceiling >= 3000.0 {
|
|
metar.flight_category = FlightCategory::VFR;
|
|
} else if visibility >= 3.0 && ceiling >= 1000.0 {
|
|
metar.flight_category = FlightCategory::MVFR;
|
|
} else if visibility >= 1.0 && ceiling >= 500.0 {
|
|
metar.flight_category = FlightCategory::IFR;
|
|
} else {
|
|
metar.flight_category = FlightCategory::LIFR;
|
|
}
|
|
}
|
|
|
|
metars.push(metar);
|
|
}
|
|
return Ok(metars)
|
|
}
|
|
|
|
fn get_missing_metar_icaos(db_metars: &Vec<Self>, station_icaos: &Vec<&str>) -> Vec<String> {
|
|
let mut missing_metar_icaos: Vec<String> = vec![];
|
|
let current_time = chrono::Local::now().naive_local().timestamp();
|
|
let db_metars_set: HashSet<&str> = db_metars.iter().map(|icao| icao.station_id.as_str()).collect();
|
|
let station_icaos_set: HashSet<&str> = station_icaos.to_owned().into_iter().collect();
|
|
for difference in db_metars_set.symmetric_difference(&station_icaos_set) {
|
|
missing_metar_icaos.push(difference.to_string());
|
|
}
|
|
for metar in db_metars {
|
|
if current_time > (metar.observation_time.timestamp() + 3600) {
|
|
trace!("{} METAR data is outdated", metar.station_id);
|
|
missing_metar_icaos.push(metar.station_id.to_string());
|
|
}
|
|
}
|
|
return missing_metar_icaos;
|
|
}
|
|
|
|
async fn get_remote_metars(icaos: String) -> Vec<Metar> {
|
|
let gov_api_url = std::env::var("GOV_API_URL").expect("GOV_API_URL must be set");
|
|
let url = format!("{}/metar.php?ids={}", gov_api_url, icaos);
|
|
match reqwest::get(url).await {
|
|
Ok(r) => match r.text().await {
|
|
Ok(r) => {
|
|
let metar_strings = r.trim().split("\n").filter(|m| !m.trim().is_empty()).collect();
|
|
match Metar::parse(metar_strings) {
|
|
Ok(m) => m,
|
|
Err(err) => {
|
|
warn!("{}", err);
|
|
vec![]
|
|
}
|
|
}
|
|
},
|
|
Err(err) => {
|
|
warn!("Unable to parse METAR request: {}", err);
|
|
vec![]
|
|
}
|
|
},
|
|
Err(err) => {
|
|
warn!("Unable to get METAR request: {}", err);
|
|
vec![]
|
|
}
|
|
}
|
|
}
|
|
|
|
fn from_query(query_metars: Vec<QueryMetar>) -> Vec<Self> {
|
|
let mut metars: Vec<Metar> = vec![];
|
|
for metar in query_metars {
|
|
let mut metar: Metar = serde_json::from_value(metar.data).unwrap();
|
|
metar.raw_text = metar.raw_text.to_string();
|
|
metar.station_id = metar.station_id.to_string();
|
|
metars.push(metar);
|
|
}
|
|
return metars;
|
|
}
|
|
|
|
fn to_insert(metars: &Vec<Self>) -> Vec<InsertMetar> {
|
|
let mut insert_metars: Vec<InsertMetar> = vec![];
|
|
for metar in metars {
|
|
insert_metars.push(InsertMetar {
|
|
station_id: metar.station_id.to_string(),
|
|
observation_time: metar.observation_time,
|
|
raw_text: metar.raw_text.to_string(),
|
|
data: serde_json::to_value(metar).unwrap()
|
|
});
|
|
}
|
|
return insert_metars;
|
|
}
|
|
|
|
pub async fn get_all(icao_string: String) -> Result<Vec<Self>, ServiceError> {
|
|
if icao_string.is_empty() {
|
|
return Ok(vec![]);
|
|
}
|
|
|
|
let icaos: Vec<&str> = icao_string.split(",").collect();
|
|
|
|
let mut db_metars = match QueryMetar::get_all(&icaos) {
|
|
Ok(m) => Self::from_query(m),
|
|
Err(err) => return Err(err)
|
|
};
|
|
|
|
let missing_icaos = Self::get_missing_metar_icaos(&db_metars, &icaos);
|
|
if missing_icaos.is_empty() {
|
|
return Ok(db_metars);
|
|
}
|
|
trace!("Retrieving missing METAR data for {:?}", missing_icaos);
|
|
let missing_icaos_string: Vec<String> = missing_icaos.iter().map(|icao| format!("{}", icao.to_string())).collect();
|
|
let mut missing_metars = Self::get_remote_metars(missing_icaos_string.join(",")).await;
|
|
if missing_metars.len() > 0 {
|
|
let insert_metars = Self::to_insert(&missing_metars);
|
|
match InsertMetar::insert(&insert_metars) {
|
|
Ok(rows) => trace!("Inserted {} metar rows", rows),
|
|
Err(err) => warn!("Unable to insert metar data; {}", err)
|
|
};
|
|
}
|
|
let mut metars: Vec<Metar> = vec![];
|
|
metars.append(&mut missing_metars);
|
|
metars.append(&mut db_metars);
|
|
Ok(metars)
|
|
}
|
|
}
|
|
|
|
#[derive(Serialize, Deserialize, AsChangeset, Insertable)]
|
|
#[diesel(table_name = metars)]
|
|
struct InsertMetar {
|
|
station_id: String,
|
|
observation_time: chrono::NaiveDateTime,
|
|
raw_text: String,
|
|
data: serde_json::Value
|
|
}
|
|
|
|
impl InsertMetar {
|
|
fn insert(metars: &Vec<Self>) -> Result<usize, ServiceError> {
|
|
let mut conn = db::connection()?;
|
|
match diesel::insert_into(metars::table).values(metars).execute(&mut conn) {
|
|
Ok(rows) => Ok(rows),
|
|
Err(err) => Err(ServiceError { status: 500, message: format!("{}", err) })
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Serialize, Deserialize, Queryable, QueryableByName)]
|
|
#[diesel(table_name = metars)]
|
|
struct QueryMetar {
|
|
id: i32,
|
|
station_id: String,
|
|
observation_time: chrono::NaiveDateTime,
|
|
raw_text: String,
|
|
data: serde_json::Value
|
|
}
|
|
|
|
impl QueryMetar {
|
|
fn get_all(icaos: &Vec<&str>) -> Result<Vec<QueryMetar>, ServiceError> {
|
|
let station_query: Vec<String> = icaos.iter().map(|icao| format!("'{}'", icao.to_string())).collect();
|
|
|
|
let mut conn = db::connection()?;
|
|
let db_metars: Vec<Self> = match sql_query(
|
|
format!("SELECT DISTINCT ON (station_id) * FROM metars WHERE station_id IN ({}) ORDER BY station_id, observation_time DESC", station_query.join(","))
|
|
).load(&mut conn) {
|
|
Ok(m) => m,
|
|
Err(err) => return Err(ServiceError { status: 500, message: format!("{}", err) })
|
|
};
|
|
return Ok(db_metars);
|
|
}
|
|
}
|