From 130d8907335c93e48017c13e3202816d552683c9 Mon Sep 17 00:00:00 2001 From: stuebinm Date: Tue, 25 Jan 2022 23:07:23 +0100 Subject: hacky proof of concept --- src/iceportal.rs | 67 ++++++++++++++++++ src/lib.rs | 5 ++ src/main.rs | 145 ++++++++++++++++++++++++++++++++++++++ src/travelynx.rs | 64 +++++++++++++++++ src/types.rs | 208 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 489 insertions(+) create mode 100644 src/iceportal.rs create mode 100644 src/lib.rs create mode 100644 src/main.rs create mode 100644 src/travelynx.rs create mode 100644 src/types.rs (limited to 'src') diff --git a/src/iceportal.rs b/src/iceportal.rs new file mode 100644 index 0000000..1b36556 --- /dev/null +++ b/src/iceportal.rs @@ -0,0 +1,67 @@ +use serde::Deserialize; +use serde_json::Value; + +use crate::travelynx::TrainRef; + +#[derive(Deserialize, Debug)] +#[serde(rename_all = "camelCase")] +pub struct TripInfo { + trip: Trip, + connection: Option, + selected_route: Option, + active: Option +} + +#[derive(Deserialize, Debug)] +#[serde(rename_all = "camelCase")] +struct Trip { + train_type: String, + vzn: String, // train number + // some position info here + actual_position: u64, // distance along track, presumably + stops: Vec +} + +#[derive(Deserialize, Debug)] +#[serde(rename_all = "camelCase")] +struct Stop { + info: StopInfo, + station: Station +} + +#[derive(Deserialize, Debug)] +#[serde(rename_all = "camelCase")] +struct StopInfo { + distance_from_start: u64, + position_status: String // one of "departed", "future", ... ? +} + +#[derive(Deserialize, Debug)] +#[serde(rename_all = "camelCase")] +struct Station { + eva_nr: String, + name: String +} + + +impl TripInfo { + + pub fn guess_last_station (&self) -> Option { + let current_pos = self.trip.actual_position; + self.trip + .stops + .iter() + .rev() + .map(|stop| (stop.info.distance_from_start, stop)) + .filter(|(dist,_)| dist <= ¤t_pos) + .next() + .map(|(_,stop)| stop.station.name.clone()) + } + + pub fn get_train_ref (&self) -> TrainRef { + TrainRef { + _type: self.trip.train_type.clone(), + no: self.trip.vzn.clone() + } + } +} diff --git a/src/lib.rs b/src/lib.rs new file mode 100644 index 0000000..a528cec --- /dev/null +++ b/src/lib.rs @@ -0,0 +1,5 @@ + + +pub mod types; +pub mod travelynx; +pub mod iceportal; diff --git a/src/main.rs b/src/main.rs new file mode 100644 index 0000000..12c67a8 --- /dev/null +++ b/src/main.rs @@ -0,0 +1,145 @@ +use clap::{Parser, Subcommand}; + +use colored::*; + +use traveltext::types::*; +use traveltext::{travelynx::*, iceportal::*}; + + +#[allow(non_upper_case_globals)] +const token: &str = "1387-d942ee22-1d34-4dc2-89b6-5e7ef229fb5e"; +#[allow(non_upper_case_globals)] +const baseurl: &str = "https://travelynx.de"; + + + +#[derive(Parser)] +struct Cli { + #[clap(subcommand)] + command: Command, +} + +#[derive(Subcommand)] +enum Command { + /// Get current travelynx status + Status, + /// Check in to a train using travelynx + Checkin { + from: String, + to: String, + // TODO: make this optional and guess which train if not given + #[clap(flatten)] + train: TrainRef + }, + /// If iceportal.de is available, ask it which train we're in and + /// check in + Autocheckin, + /// Undo the last checkin (if any). + Undo, + /// Query iceportal.de (for testing) + ICEPortal +} + + + +fn main() -> Result<(), ureq::Error> { + let cli = Cli::parse(); + + let traveltext = format!( + "{}{}el{}{}", + "tr".cyan(), + "av".bright_magenta(), + "te".bright_magenta(), + "xt".cyan() + ); + + match cli.command { + Command::Status => { + let body: Status = ureq::get(&format!("{}/api/v1/status/{}", baseurl, token)) + .call() + // TODO: this prints the token! + .unwrap_or_else(|err| exit_err(&err.to_string())) + .into_json() + .unwrap_or_else(|err| exit_err(&err.to_string())); + + println!("{}: {}", traveltext, body); + } + Command::Checkin {from, to, train} => { + let request = Action::CheckIn { + train, + from_station: from, + to_station: Some(to), + comment: None, + token: format!("{}", token) + }; + + // println!("{}", serde_json::to_string(&request).unwrap()); + + let resp: Response = ureq::post(&format!("{}/api/v1/travel", baseurl)) + .send_json(request) + .unwrap_or_else(|err| exit_err(&err.to_string())) + .into_json() + .unwrap_or_else(|err| exit_err(&err.to_string())); + + // eprintln!("{:?}", resp); + println!("{}: {}", traveltext, resp); + }, + Command::Undo => { + let resp: Response = ureq::post(&format!("{}/api/v1/travel", baseurl)) + .send_json(Action::Undo {token: token.to_owned()}) + .unwrap_or_else(|err| exit_err(&err.to_string())) + .into_json() + .unwrap_or_else(|err| exit_err(&err.to_string())); + + println!("{}: {}", traveltext, resp); + }, + Command::Autocheckin => { + let iceportal: TripInfo = ureq::get("https://iceportal.de/api1/rs/tripInfo/trip") + .call()? + .into_json() + .unwrap_or_else(|err| exit_err(&err.to_string())); + let last_stop = iceportal.guess_last_station().unwrap(); + let train = iceportal.get_train_ref(); + println!( + "{}: guessing you got onto {} {} in {}, checking in …", + traveltext, + train._type, + train.no, + last_stop + ); + let request = Action::CheckIn { + train, + from_station: last_stop, + to_station: None, + comment: None, + token: format!("{}", token) + }; + + // println!("{}", serde_json::to_string(&request).unwrap()); + + let resp: Response = ureq::post(&format!("{}/api/v1/travel", baseurl)) + .send_json(request) + .unwrap_or_else(|err| exit_err(&err.to_string())) + .into_json() + .unwrap_or_else(|err| exit_err(&err.to_string())); + + // eprintln!("{:?}", resp); + println!("{}: {}", traveltext, resp); + + }, + Command::ICEPortal => { + let resp: TripInfo = ureq::get("https://iceportal.de/api1/rs/tripInfo/trip") + .call()? + .into_json() + .unwrap_or_else(|err| exit_err(&err.to_string())); + println!("{:?}", resp); + println!("guessing last stop was: {:?}", resp.guess_last_station()); + } + } + Ok(()) +} + +fn exit_err(msg: &str) -> ! { + eprintln!("{}", msg); + std::process::exit(1) +} diff --git a/src/travelynx.rs b/src/travelynx.rs new file mode 100644 index 0000000..0188f32 --- /dev/null +++ b/src/travelynx.rs @@ -0,0 +1,64 @@ +use clap::Args; +use serde::{Serialize, Deserialize}; +use colored::*; + +use crate::types::Status; + +#[derive(Serialize)] +#[serde(rename_all = "camelCase")] +pub struct Travel { + token: String, + #[serde(flatten)] + action: Action, +} + +#[derive(Serialize, Debug)] +#[serde(rename_all = "camelCase")] +#[serde(tag = "action")] +pub enum Action { + #[serde(rename = "checkin")] + #[serde(rename_all = "camelCase")] + CheckIn { + token: String, + train: TrainRef, + from_station: String, + #[serde(skip_serializing_if = "Option::is_none")] + to_station: Option, + #[serde(skip_serializing_if = "Option::is_none")] + comment: Option, + }, + #[serde(rename = "checkout")] + CheckOut { + to_station: String, + force: bool, + #[serde(skip_serializing_if = "Option::is_none")] + comment: Option, + }, + Undo {token: String}, +} + +#[derive(Args, Serialize, Debug)] +pub struct TrainRef { + #[clap(name = "TRAIN TYPE")] + #[serde(rename = "type")] + pub _type: String, + #[clap(name = "NUMBER")] + pub no: String, +} + +#[derive(Deserialize, Debug)] +pub struct Response { + success: Option, + deprecated: bool, + status: Status, + error: Option +} + +impl std::fmt::Display for Response { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match &self.error { + Some(msg) => write!(f, "{}", msg.red()), + None => write!(f, "{}\n\n{}", "Success!".green(), self.status) + } + } +} diff --git a/src/types.rs b/src/types.rs new file mode 100644 index 0000000..3dcb6db --- /dev/null +++ b/src/types.rs @@ -0,0 +1,208 @@ +use serde::{Deserialize, Deserializer}; + +use chrono::NaiveDateTime; +use colored::*; +use itertools::Itertools; + +#[derive(Deserialize, Debug)] +#[serde(rename_all = "camelCase")] +pub struct Station { + name: String, + ds100: String, + uic: u64, + latitude: f64, + longitude: f64, + #[serde(deserialize_with = "naive_read_unixtime")] + scheduled_time: NaiveDateTime, + #[serde(deserialize_with = "naive_read_unixtime")] + real_time: NaiveDateTime, +} + + +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) + } +} + + +fn naive_read_unixtime<'de, D>(d: D) -> Result +where + D: Deserializer<'de>, +{ + let ts = ::deserialize(d)?; + Ok(NaiveDateTime::from_timestamp(ts, 0)) +} +fn option_naive_read_unixtime<'de, D>(d: D) -> Result, D::Error> +where + D: Deserializer<'de>, +{ + match ::deserialize(d) { + Ok(ts) => + Ok(Some(NaiveDateTime::from_timestamp(ts, 0))), + 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, +} + +trait IsStation { + fn name (&self) -> &str; + fn scheduled_arrival (&self) -> Option<&NaiveDateTime>; + fn real_arrival (&self) -> Option<&NaiveDateTime>; + fn ds100 (&self) -> &str; + + fn to_fancy_string (&self) -> String { + format!( + "{} {} – {} ({})", + self.real_arrival().map(|t| t.time().to_string()).unwrap_or("??:??:??".to_string()).blue(), + { + let delay = match (self.real_arrival(), self.scheduled_arrival()) { + (Some(a), Some(s)) => (a.time() - s.time()).num_minutes(), + _ => 0 + }; + let text = format!("({:+})", delay); + if delay > 0 { + text.red() + } else { + text.green() + } + }, + self.ds100().red(), + self.name() + ) + } +} + +impl IsStation for Station { + fn name (&self) -> &str { + &self.name + } + fn scheduled_arrival (&self) -> Option<&NaiveDateTime> { + Some(&self.scheduled_time) + } + fn real_arrival (&self) -> Option<&NaiveDateTime> { + Some(&self.real_time) + } + + fn ds100 (&self) -> &str { + &self.ds100 + } +} + +impl IsStation for Stop { + fn name (&self) -> &str { + &self.name + } + fn scheduled_arrival (&self) -> Option<&NaiveDateTime> { + self.scheduled_arrival.as_ref() + } + fn real_arrival (&self) -> Option<&NaiveDateTime> { + self.real_arrival.as_ref() + } + + fn ds100 (&self) -> &str { + "[??]" + } +} + + + + +#[derive(Deserialize, Debug)] +#[serde(rename_all = "camelCase")] +pub struct Train { + #[serde(rename = "type")] + _type: String, + line: Option, + no: String, + id: String, +} + + + +#[derive(Deserialize, Debug)] +#[serde(rename_all = "camelCase")] +pub struct Status { + deprecated: bool, + checked_in: bool, + from_station: Station, + #[serde(deserialize_with = "parse_optional_station")] + to_station: Option, + intermediate_stops: Vec, + train: Option, + action_time: u64, +} + +#[allow(dead_code)] +pub struct Ds100 { + inner: String, +} + +struct Trip<'a> (&'a Vec); + +impl std::fmt::Display for Train { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "{} {}", self._type, self.no) + } +} + +#[allow(unstable_name_collisions)] +impl std::fmt::Display for Trip<'_> { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + if self.0.len() == 0 { + write!(f, "(none)") + } else { + self.0.iter() + .map(|stop| stop.to_fancy_string()) + .intersperse(" ↓".to_string()) + .for_each(|l| writeln!(f, " {}", l).unwrap()); + Ok(()) + } + } +} + + +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 {}\n ↓\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{} ↓\n {}", + self.train.as_ref().map(|t| t.to_string()).unwrap_or("".to_string()).green(), + self.from_station.to_fancy_string(), + Trip(&self.intermediate_stops), + self.to_station + .as_ref() + .map(|s| s.to_fancy_string()) + .unwrap_or_else(|| "🚄 Fahrt ins Blaue".blue().to_string()) + ) + } + } +} -- cgit v1.2.3