95 lines
2.7 KiB
Rust
95 lines
2.7 KiB
Rust
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;
|
|
use std::error::Error;
|
|
|
|
/// Endpoint for the search feature
|
|
const SEARCH_URL: &str = "https://www.ivago.be/nl/particulier/autocomplete/garbage/streets";
|
|
|
|
impl From<Street> for String {
|
|
fn from(street: Street) -> String {
|
|
format!("{} ({})", street.name, street.city)
|
|
}
|
|
}
|
|
|
|
impl Serialize for Street {
|
|
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
|
|
where
|
|
S: Serializer,
|
|
{
|
|
let mut s = serializer.serialize_struct("Street", 2)?;
|
|
s.serialize_field("name", &self.name)?;
|
|
s.serialize_field("city", &self.city)?;
|
|
s.end()
|
|
}
|
|
}
|
|
|
|
impl TryFrom<String> for Street {
|
|
type Error = ();
|
|
|
|
fn try_from(value: String) -> Result<Self, Self::Error> {
|
|
if let Some(index) = value.find('(') {
|
|
Ok(Street {
|
|
name: (value[0..index - 1].trim()).to_string(),
|
|
city: (value[index + 1..value.len() - 1].trim()).to_string(),
|
|
})
|
|
} else {
|
|
Err(())
|
|
}
|
|
}
|
|
}
|
|
|
|
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,
|
|
pub city: String,
|
|
}
|
|
|
|
/// Searches the Ivago API for streets in the given city
|
|
///
|
|
/// # Arguments
|
|
///
|
|
/// * `street` - name of the street
|
|
/// * `city` - city the street is in
|
|
// TODO find out how to do this async
|
|
pub fn search_streets(street_name: &String) -> Result<Vec<Street>, Box<dyn Error>> {
|
|
let client = reqwest::Client::new();
|
|
let response = client.get(SEARCH_URL).query(&[("q", street_name)]).send()?;
|
|
let data: Vec<HashMap<String, String>> = response.json()?;
|
|
|
|
let mut output: Vec<Street> = Vec::new();
|
|
|
|
// We iterate over every item and extract the needed data
|
|
for map in data.iter() {
|
|
if let Some(value) = map.get("value") {
|
|
match Street::try_from(value.clone()) {
|
|
Ok(street) => output.push(street),
|
|
Err(_) => continue,
|
|
}
|
|
}
|
|
}
|
|
|
|
Ok(output)
|
|
}
|