use serde::{Deserialize, Deserializer}; use chrono::{DateTime, Utc}; use colored::*; use crate::serde::*; use crate::traits::IsStation; #[derive(Deserialize, Debug)] #[serde(rename_all = "camelCase")] pub struct Station { name: String, pub ds100: Option, uic: u64, latitude: f64, longitude: f64, #[serde(deserialize_with = "naive_read_unixtime")] scheduled_time: DateTime, #[serde(deserialize_with = "naive_read_unixtime")] real_time: DateTime } pub fn parse_optional_station<'de, D>(d: D) -> Result, D::Error> where D: Deserializer<'de> { let val = ::deserialize(d)?; match serde_json::from_value(val) { Ok(station) => Ok(Some(station)), Err(_) => Ok(None) } } #[derive(Deserialize, Debug)] #[serde(rename_all = "camelCase")] pub struct Stop { name: String, #[serde(deserialize_with = "option_naive_read_unixtime")] scheduled_arrival: Option>, #[serde(deserialize_with = "option_naive_read_unixtime")] real_arrival: Option>, #[serde(deserialize_with = "option_naive_read_unixtime")] scheduled_departure: Option>, #[serde(deserialize_with = "option_naive_read_unixtime")] real_departure: Option> } impl IsStation for Station { fn name(&self) -> &str { &self.name } fn scheduled_arrival(&self) -> Option<&DateTime> { Some(&self.scheduled_time) } fn real_arrival(&self) -> Option<&DateTime> { Some(&self.real_time) } fn ds100(&self) -> Option<&str> { self.ds100.as_deref() } } impl IsStation for Stop { fn name(&self) -> &str { &self.name } fn scheduled_arrival(&self) -> Option<&DateTime> { self.scheduled_arrival.as_ref() } fn real_arrival(&self) -> Option<&DateTime> { self.real_arrival.as_ref() } fn ds100(&self) -> Option<&str> { None } } #[derive(Deserialize, Debug)] #[serde(rename_all = "camelCase")] pub struct Train { #[serde(rename = "type")] pub _type: String, pub line: Option, pub no: String, pub id: String } impl std::fmt::Display for Train { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { write!(f, "{} {}", self._type, self.no) } } #[derive(Deserialize, Debug)] #[serde(rename_all = "camelCase")] pub struct Status { deprecated: bool, pub checked_in: bool, pub from_station: Station, #[serde(deserialize_with = "parse_optional_station")] pub to_station: Option, intermediate_stops: Vec, pub train: Option, action_time: u64 } #[allow(dead_code)] pub struct Ds100 { inner: String } /// this type is a little silly, but apparently there's no better way /// to 'forget' what the concrete type is than re-constructing the vec? pub struct Trip<'a>(Vec<&'a dyn IsStation>); impl std::fmt::Display for Trip<'_> { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { if self.0.len() != 0 { self .0 .iter() .map(|stop| stop.to_fancy_string()) .for_each(|l| writeln!(f, " {}\n ↓", l).unwrap()); } Ok(()) } } /// with this, you sometimes have to write (&self.stops).into() /// yay for reference syntax! impl<'a, S: IsStation + 'a> From<&'a Vec> for Trip<'a> { fn from(from: &'a Vec) -> Self { Trip(from.iter().map(|s| s as &dyn IsStation).collect()) } } impl std::fmt::Display for Status { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self.checked_in { false => write!( f, "not checked in. \n\n\ last trip: \n {} {}", self.from_station.to_fancy_string(), self.to_station.as_ref().unwrap().to_fancy_string() ), true => write!( f, "checked in to: {}.\n\n\ stops:\n {}\n ↓\n{} {}", self .train .as_ref() .map(|t| t.to_string()) .unwrap_or("".to_string()) .green(), self.from_station.to_fancy_string(), Trip::from(&self.intermediate_stops), self .to_station .as_ref() .map(|s| s.to_fancy_string()) .unwrap_or_else(|| "🚄 Fahrt ins Blaue".blue().to_string()) ) } } }