From cfe75d92d60fbb89fba13760be69ca3c76bb609d Mon Sep 17 00:00:00 2001 From: Shell1010 Date: Sat, 27 Jan 2024 19:44:18 +0000 Subject: [PATCH] Added Stop Points --- lines/src/client.rs | 46 +++++++++++++++++++++--------- lines/src/datastructs.rs | 6 ++++ lines/src/lib.rs | 61 +++++++++++++++++++++++++++++----------- lines/src/main.rs | 41 +++++++++++++-------------- 4 files changed, 102 insertions(+), 52 deletions(-) diff --git a/lines/src/client.rs b/lines/src/client.rs index 3b62ce7..458d473 100644 --- a/lines/src/client.rs +++ b/lines/src/client.rs @@ -1,7 +1,7 @@ use reqwest; use serde_json::{Value, from_str, from_value}; -use crate::datastructs::{DataStruct, QuerySearch, Version, LineRoute}; +use crate::datastructs::{DataStruct, LineRoute, QuerySearch, Response, StopPoint, Version}; use crate::lines::Line; #[derive(Debug)] @@ -60,7 +60,7 @@ impl Client { self.modify_endpoint(line) } - pub fn fetch(&self) -> Result { + pub fn fetch(&self) -> Result { if let Some(url) = &self.url { let resp = self.req().get(format!("{}/{}", &self.root, url)).send(); match resp { @@ -69,19 +69,37 @@ impl Client { match text { Ok(text) => { - // return Ok(from_str(&text).unwrap()) + // return Ok(fro"Tfl.Api.Common.ApiVersionInfo, Tfl.Api.Commonm_str(&text).unwrap()) if let Ok(real_data) = from_str::(&text) { - if let Value::Array(_) = real_data { - - if real_data[0]["$type"] == "Tfl.Api.Presentation.Entities.Line, Tfl.Api.Presentation.Entities" { - for data in real_data.as_array().unwrap() { - let data: Result = from_value(data.to_owned()); - if let Ok(data) = data { - return Ok(DataStruct::from(data)) + if let Value::Array(val) = &real_data { + match &val[0]["$type"] { + Value::String(v) => { + match v.as_str() { + "Tfl.Api.Presentation.Entities.Line, Tfl.Api.Presentation.Entities" => { + let data = val.into_iter().map(|v| if let Ok(data) = from_value::(v.to_owned()) { + DataStruct::from(data) + } else { + DataStruct::from(LineRoute::default()) + }).collect(); + return Ok(Response::Multiple(data)) + }, + + "Tfl.Api.Presentation.Entities.StopPoint, Tfl.Api.Presentation.Entities" => { + let data = val.into_iter().map(|v| if let Ok(data) = from_value::(v.to_owned()) { + DataStruct::from(data) + } else { + DataStruct::from(StopPoint::default()) + }).collect(); + return Ok(Response::Multiple(data)) + } + _ => () } - } + }, + _ => () } + + } @@ -92,19 +110,19 @@ impl Client { "Tfl.Api.Presentation.Entities.RouteSearchResponse, Tfl.Api.Presentation.Entities" => { let data: Result = from_value(real_data); if let Ok(data) = data { - return Ok(DataStruct::from(data)) + return Ok(Response::Single(DataStruct::from(data))) } }, "Tfl.Api.Common.ApiVersionInfo, Tfl.Api.Common" => { let data: Result = from_value(real_data); if let Ok(data) = data { - return Ok(DataStruct::from(data)) + return Ok(Response::Single(DataStruct::from(data))) } }, "Tfl.Api.Presentation.Entities.Line, Tfl.Api.Presentation.Entities" => { let data: Result = from_value(real_data.clone()); if let Ok(data) = data { - return Ok(DataStruct::from(data)) + return Ok(Response::Single(DataStruct::from(data))) } } _ => return Err(TflError::ApiError(format!("Couldn't deserialize: {real_data:#?}"))) diff --git a/lines/src/datastructs.rs b/lines/src/datastructs.rs index a39c2ea..ade027e 100644 --- a/lines/src/datastructs.rs +++ b/lines/src/datastructs.rs @@ -10,6 +10,12 @@ pub trait JsonTrait { } } +#[derive(Debug, Serialize, Deserialize)] +pub enum Response { + Single(DataStruct), + Multiple(Vec) +} + // Line/Search/ #[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)] #[serde(rename_all = "camelCase")] diff --git a/lines/src/lib.rs b/lines/src/lib.rs index a95bc4f..d4b153d 100644 --- a/lines/src/lib.rs +++ b/lines/src/lib.rs @@ -4,35 +4,46 @@ mod datastructs; #[cfg(test)] mod tests { - use crate::{client::Client, datastructs::DataStruct, lines::Line}; + + + use crate::{client::Client, datastructs::{Response, DataStruct}, lines::Line}; #[test] fn search_test() { // Does test for search/query let resp = Client::new("abcd1234").query("ok").fetch().unwrap(); - if let DataStruct::QuerySearch(data) = resp { - assert!("Tfl.Api.Presentation.Entities.RouteSearchResponse, Tfl.Api.Presentation.Entities" == data.type_field, "Type Returned: {}", data.type_field) - } else { - assert!(false, "{:?}", resp) + if let Response::Single(data) = resp { + if let DataStruct::QuerySearch(data) = data { + assert!("Tfl.Api.Presentation.Entities.RouteSearchResponse, Tfl.Api.Presentation.Entities" == data.type_field, "Type Returned: {}", data.type_field) + } else { + assert!(false, "{:?}", data) + } } } #[test] fn version_test() { let resp = Client::new("abcd1234").version().fetch().unwrap(); - if let DataStruct::Version(data) = resp { - assert!("Tfl.Api.Common.ApiVersionInfo, Tfl.Api.Common" == data.type_field, "Type Returned: {}", data.type_field) - } else { - assert!(false, "{:?}", resp) + if let Response::Single(data) = resp { + if let DataStruct::Version(data) = data { + assert!("Tfl.Api.Common.ApiVersionInfo, Tfl.Api.Common" == data.type_field, "Type Returned: {}", data.type_field) + } else { + assert!(false, "{:?}", data) + } } + } #[test] fn line_test() { let line = Line::Jubilee; let resp = Client::new("abcd1234").line(&line.line()).fetch().unwrap(); - if let DataStruct::LineRoute(data) = resp { - - assert!("Tfl.Api.Presentation.Entities.Line, Tfl.Api.Presentation.Entities" == data.type_field, "Type Returned: {:?}", data) + if let Response::Multiple(data) = resp { + for data in data { + if let DataStruct::LineRoute(data) = data { + assert!("Tfl.Api.Presentation.Entities.Line, Tfl.Api.Presentation.Entities" == data.type_field, "Type Returned: {}", data.type_field) + } else { + assert!(false, "{:?}", data) + }} } else { assert!(false, "{:?}", resp) } @@ -42,13 +53,29 @@ mod tests { fn route_test() { let line = Line::Bakerloo; let resp = Client::new("abcd1234").route(&line.route()).fetch().unwrap(); - if let DataStruct::LineRoute(data) = resp { - - assert!("Tfl.Api.Presentation.Entities.Line, Tfl.Api.Presentation.Entities" == data.type_field, "Type Returned: {}", data.type_field) - } else { - assert!(false, "{:?}", resp) + if let Response::Single(data) = resp { + if let DataStruct::LineRoute(data) = data { + assert!("Tfl.Api.Presentation.Entities.Line, Tfl.Api.Presentation.Entities" == data.type_field, "Type Returned: {}", data.type_field) + } else { + assert!(false, "{:?}", data) + } } } + #[test] + fn station_test() { + let line = Line::Bakerloo; + let resp = Client::new("abcd1234").route(&line.stations()).fetch().unwrap(); + if let Response::Multiple(data) = resp { + for data in data { + if let DataStruct::StopPoint(data) = data { + + assert!("Tfl.Api.Presentation.Entities.StopPoint, Tfl.Api.Presentation.Entities" == data.type_field, "Type Returned: {}", data.type_field) + } else { + assert!(false, "{:#?}", data) + } + } + } + } } diff --git a/lines/src/main.rs b/lines/src/main.rs index 6ba4a07..a0a3dea 100644 --- a/lines/src/main.rs +++ b/lines/src/main.rs @@ -4,26 +4,25 @@ mod client; use client::{Client, Request}; use lines::Line; -use datastructs::{DataStruct, QuerySearch, SearchMatch}; +use datastructs::{DataStruct, QuerySearch, SearchMatch, Response}; -fn main() { - let client = Client::new("abcd"); - let res: DataStruct = client.route(Line::Central.line()).fetch().unwrap(); - - match res { - DataStruct::QuerySearch(data) => { - for matched in data.search_matches { - println!("{}", matched.line_name); +fn main() { + let line = Line::Bakerloo; + let resp = Client::new("abcd1234").line(&line.line()).fetch().unwrap(); + match resp { + Response::Single(data) => { + if let DataStruct::LineRoute(data) = data { + println!("{:#?}", data.type_field); + } else { + assert!(false, "{:?}", data) + } } - }, - - DataStruct::Version(data) => { - println!("{}", data.type_field) - }, - - DataStruct::LineRoute(data) => println!("{}", data.type_field), - - _ => () - } - -} \ No newline at end of file + Response::Multiple(data) => { + for data in data { + println!("{:#?}", data); + } + } + } + + +}