[#4] Finally got proper form value handling (#1)

src/ivago/controller/mod.rs

@@ -1,6 +1,6 @@
 mod pickup_times;
 mod search;
-pub use pickup_times::{get_pickup_times, PickupTime};
+pub use pickup_times::{get_pickup_times, BasicDate, PickupTime};
 pub use search::{search_streets, Street};
 
 ///// Return the known pickup times for the given street and/or city

src/ivago/controller/pickup_times.rs

@@ -1,36 +1,83 @@
 use super::search::Street;
-use chrono::NaiveDate;
+use regex::Regex;
 use rocket::http::RawStr;
 use rocket::request::FromFormValue;
+use serde::ser::{Serialize, SerializeStruct, Serializer};
 use std::error::Error;
 
 const BASE_URL: &str = "https://www.ivago.be/nl/particulier/afval/ophaling";
 
+/// Represents a very simple Timezoneless date. Considering the timezone will
+/// always be CEST (aka Belgium's timezone), this is good enough.
+pub struct BasicDate {
+    year: u32,
+    month: u8,
+    day: u8,
+}
+
+impl<'v> FromFormValue<'v> for BasicDate {
+    type Error = &'v RawStr;
+
+    fn from_form_value(form_value: &'v RawStr) -> Result<BasicDate, Self::Error> {
+        // Beautiful how  this exact example is in the docs
+        let re = Regex::new(r"^(\d{4})-(\d{2})-(\d{2})$").unwrap();
+        match re.captures(form_value) {
+            None => Err(form_value),
+            // Here, we can assume these parses will work, because the regex
+            // didn't fail
+            Some(caps) => Ok(BasicDate {
+                year: caps.get(1).unwrap().as_str().parse().unwrap(),
+                month: caps.get(2).unwrap().as_str().parse().unwrap(),
+                day: caps.get(3).unwrap().as_str().parse().unwrap(),
+            }),
+        }
+    }
+}
+
+impl ToString for BasicDate {
+    fn to_string(&self) -> String {
+        format!("{}-{}-{}", self.year, self.month, self.day)
+    }
+}
+
+impl Serialize for BasicDate {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str(&self.to_string())
+    }
+}
+
+impl Serialize for PickupTime {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let mut s = serializer.serialize_struct("PickupTime", 4)?;
+        s.serialize_field("date", &self.date)?;
+        s.serialize_field("label", &self.label)?;
+        s.serialize_field("classes", &self.classes)?;
+        s.serialize_field("url", &self.url)?;
+
+        s.end()
+    }
+}
+
 /// Represents a pickup time instance. All fields are a direct map of the
 /// original API
 pub struct PickupTime {
-    date: NaiveDate,
+    date: BasicDate,
     label: String,
     classes: Vec<String>,
     url: String,
 }
 
-impl<'v> FromFormValue<'v> for NaiveDate {
-    type Error = &'v RawStr;
-
-    fn from_form_value(form_value: &'v RawStr) -> Result<NaiveDate, &'v RawStr> {
-        match NaiveDate::parse_from_str(form_value, "%Y-%m-%d") {
-            Ok(date) => Ok(date),
-            Err(_) => Err(form_value),
-        }
-    }
-}
-
 pub fn get_pickup_times(
     street: Street,
-    number: u64,
-    start_date: NaiveDate,
-    end_date: NaiveDate,
+    number: u32,
+    start_date: BasicDate,
+    end_date: BasicDate,
 ) -> Result<Vec<PickupTime>, Box<dyn Error>> {
     Ok(Vec::new())
 }

src/ivago/controller/search.rs

@@ -1,4 +1,7 @@
+use regex::Regex;
 use reqwest::blocking as reqwest;
+use rocket::http::RawStr;
+use rocket::request::FromFormValue;
 use serde::ser::{Serialize, SerializeStruct, Serializer};
 use std::collections::HashMap;
 use std::convert::TryFrom;
@@ -40,6 +43,23 @@ impl TryFrom<String> for Street {
     }
 }
 
+impl<'v> FromFormValue<'v> for Street {
+    type Error = &'v RawStr;
+
+    fn from_form_value(form_value: &'v RawStr) -> Result<Street, Self::Error> {
+        // This regex is pretty loose tbh, but not sure how I can make it more
+        // strict right now
+        let re = Regex::new(r"^(.+) \((.+)\)$").unwrap();
+        match re.captures(&form_value.url_decode_lossy()) {
+            None => Err(form_value),
+            Some(caps) => Ok(Street {
+                name: String::from(caps.get(1).unwrap().as_str()),
+                city: String::from(caps.get(2).unwrap().as_str()),
+            }),
+        }
+    }
+}
+
 /// Represents a street
 pub struct Street {
     pub name: String,

src/ivago/mod.rs

@@ -2,12 +2,11 @@ mod controller;
 #[cfg(test)]
 mod tests;
 
-use chrono::NaiveDate;
 use rocket::http::Status;
 use rocket_contrib::json::Json;
 
 pub fn routes() -> Vec<rocket::Route> {
-    routes![route_search_streets,]
+    routes![route_search_streets, route_get_pickup_times]
 }
 
 // URL: https://www.ivago.be/nl/particulier/autocomplete/garbage/streets?q=Lange
@@ -15,7 +14,7 @@ pub fn routes() -> Vec<rocket::Route> {
 pub fn route_search_streets(street: String) -> Result<Json<Vec<controller::Street>>, Status> {
     match controller::search_streets(&street) {
         Ok(streets) => Ok(Json(streets)),
-        Err(err) => Err(Status::InternalServerError),
+        Err(_) => Err(Status::InternalServerError),
     }
 }
 
@@ -23,8 +22,12 @@ pub fn route_search_streets(street: String) -> Result<Json<Vec<controller::Stree
 pub fn route_get_pickup_times(
     street: controller::Street,
     number: u32,
-    start_date: NaiveDate,
-    end_date: NaiveDate,
+    start_date: controller::BasicDate,
+    end_date: controller::BasicDate,
 ) -> Result<Json<Vec<controller::PickupTime>>, Status> {
-    Err(Status::InternalServerError)
+    match controller::get_pickup_times(street, number, start_date, end_date) {
+        // TODO provide more meaningful status codes here
+        Err(_) => Err(Status::InternalServerError),
+        Ok(times) => Ok(Json(times)),
+    }
 }