use chrono::{DateTime, Utc};
use futures_util::StreamExt;
use serde::{Deserialize, Serialize};
use serde_json::json;
use crate::authentification::CredentialsOrApiKey;
use crate::error::Result;
use crate::groups::Group;
use crate::http::{client, encode, ok};
#[derive(Debug, Clone, Copy, Default, PartialEq, Serialize, Deserialize)]
pub struct Coordinates {
pub latitude: f64,
pub longitude: f64,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct Waypoint {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub coordinates: Option<Coordinates>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub address: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub place: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Place {
pub id: String,
pub name: String,
pub address: String,
pub coordinates: Coordinates,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Suggestion {
pub place: String,
pub name: String,
pub description: String,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum TravelMode {
Drive,
Walk,
Transit,
Flight,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Money {
pub amount: f64,
pub currency: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Step {
pub mode: TravelMode,
pub instruction: String,
pub distance: f64,
pub duration: f64,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub line: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub vehicle: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub stops: Option<u32>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub from: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub to: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub departure: Option<DateTime<Utc>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub arrival: Option<DateTime<Utc>>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Route {
pub mode: TravelMode,
pub duration: f64,
pub distance: f64,
pub path: Vec<Coordinates>,
pub steps: Vec<Step>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub fare: Option<Money>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub departure: Option<DateTime<Utc>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub arrival: Option<DateTime<Utc>>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Airport {
pub code: String,
pub name: String,
pub city: String,
pub country: String,
pub coordinates: Coordinates,
pub distance: f64,
pub large: bool,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum Units {
Metric,
Imperial,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum Condition {
Clear,
PartlyCloudy,
Cloudy,
Fog,
Rain,
Showers,
Thunderstorm,
Snow,
Sleet,
Hail,
Wind,
Unknown,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ForecastDay {
pub date: String,
pub high: f64,
pub low: f64,
pub condition: Condition,
pub summary: String,
pub precipitation: f64,
pub wind: f64,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub sunrise: Option<DateTime<Utc>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub sunset: Option<DateTime<Utc>>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ForecastHour {
pub time: DateTime<Utc>,
pub temperature: f64,
pub feels_like: f64,
pub condition: Condition,
pub summary: String,
pub precipitation: f64,
pub wind: f64,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Forecast {
pub units: Units,
pub time_zone: String,
pub days: Vec<ForecastDay>,
pub hours: Vec<ForecastHour>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum MapTheme {
Light,
Dark,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Attribution {
pub text: String,
pub logo: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TilePass {
pub id: String,
pub tiles: u32,
pub expires: DateTime<Utc>,
pub size: u32,
pub max_zoom: u32,
pub attribution: Attribution,
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Serialize, Deserialize)]
pub struct Bounds {
pub north: f64,
pub south: f64,
pub east: f64,
pub west: f64,
}
#[derive(Debug, Clone, Copy, Default)]
pub struct PlaceSearchOptions {
pub near: Option<Coordinates>,
pub radius: Option<f64>,
pub max: Option<u32>,
}
#[derive(Debug, Clone, Copy, Default)]
pub struct AutocompleteOptions {
pub near: Option<Coordinates>,
}
#[derive(Debug, Clone, Default)]
pub struct RouteOptions {
pub modes: Option<Vec<TravelMode>>,
pub departure: Option<DateTime<Utc>>,
pub arrival: Option<DateTime<Utc>>,
}
#[derive(Debug, Clone, Copy, Default)]
pub struct AirportOptions {
pub max: Option<u32>,
pub large: Option<bool>,
}
#[derive(Debug, Clone, Copy, Default)]
pub struct WeatherOptions {
pub days: Option<u32>,
pub hours: Option<u32>,
pub units: Option<Units>,
}
#[derive(Debug, Clone, Default)]
pub struct TilePassOptions {
pub theme: Option<MapTheme>,
pub tiles: Option<u32>,
pub language: Option<String>,
pub region: Option<String>,
}
pub async fn geocode(
authorization: &CredentialsOrApiKey,
query: &Waypoint,
group: Option<&Group>,
) -> Result<Vec<Place>> {
let mut request = client()
.post(format!("{}/maps/geocode", crate::get_url()))
.header(
"Authorization",
match authorization {
CredentialsOrApiKey::Credentials(credentials) => {
format!("Token {}", credentials.token)
}
CredentialsOrApiKey::ApiKey(key) => format!("ApiKey {}", key.id),
},
);
if let Some(group) = group {
request = request.header("Group", &group.id);
}
let response = request.json(&json!({ "query": query })).send().await?;
Ok(ok(response).await?.json().await?)
}
pub async fn search_places(
authorization: &CredentialsOrApiKey,
text: &str,
options: &PlaceSearchOptions,
group: Option<&Group>,
) -> Result<Vec<Place>> {
let mut request = client()
.post(format!("{}/maps/places/search", crate::get_url()))
.header(
"Authorization",
match authorization {
CredentialsOrApiKey::Credentials(credentials) => {
format!("Token {}", credentials.token)
}
CredentialsOrApiKey::ApiKey(key) => format!("ApiKey {}", key.id),
},
);
if let Some(group) = group {
request = request.header("Group", &group.id);
}
let response = request
.json(&json!({
"text": text,
"near": options.near,
"radius": options.radius,
"max": options.max,
}))
.send()
.await?;
Ok(ok(response).await?.json().await?)
}
pub async fn autocomplete(
authorization: &CredentialsOrApiKey,
text: &str,
options: &AutocompleteOptions,
group: Option<&Group>,
) -> Result<Vec<Suggestion>> {
let mut request = client()
.post(format!("{}/maps/places/autocomplete", crate::get_url()))
.header(
"Authorization",
match authorization {
CredentialsOrApiKey::Credentials(credentials) => {
format!("Token {}", credentials.token)
}
CredentialsOrApiKey::ApiKey(key) => format!("ApiKey {}", key.id),
},
);
if let Some(group) = group {
request = request.header("Group", &group.id);
}
let response = request
.json(&json!({ "text": text, "near": options.near }))
.send()
.await?;
Ok(ok(response).await?.json().await?)
}
pub async fn get_routes(
authorization: &CredentialsOrApiKey,
from: &Waypoint,
to: &Waypoint,
options: &RouteOptions,
group: Option<&Group>,
) -> Result<Vec<Route>> {
let mut request = client()
.post(format!("{}/maps/routes", crate::get_url()))
.header(
"Authorization",
match authorization {
CredentialsOrApiKey::Credentials(credentials) => {
format!("Token {}", credentials.token)
}
CredentialsOrApiKey::ApiKey(key) => format!("ApiKey {}", key.id),
},
);
if let Some(group) = group {
request = request.header("Group", &group.id);
}
let response = request
.json(&json!({
"from": from,
"to": to,
"modes": options.modes,
"departure": options.departure,
"arrival": options.arrival,
}))
.send()
.await?;
Ok(ok(response).await?.json().await?)
}
pub async fn get_airports(
authorization: &CredentialsOrApiKey,
near: &Coordinates,
options: &AirportOptions,
) -> Result<Vec<Airport>> {
let response = client()
.post(format!("{}/maps/airports", crate::get_url()))
.header(
"Authorization",
match authorization {
CredentialsOrApiKey::Credentials(credentials) => {
format!("Token {}", credentials.token)
}
CredentialsOrApiKey::ApiKey(key) => format!("ApiKey {}", key.id),
},
)
.json(&json!({ "near": near, "max": options.max, "large": options.large }))
.send()
.await?;
Ok(ok(response).await?.json().await?)
}
pub async fn get_weather(
authorization: &CredentialsOrApiKey,
at: &Coordinates,
options: &WeatherOptions,
group: Option<&Group>,
) -> Result<Forecast> {
let mut request = client()
.post(format!("{}/maps/weather", crate::get_url()))
.header(
"Authorization",
match authorization {
CredentialsOrApiKey::Credentials(credentials) => {
format!("Token {}", credentials.token)
}
CredentialsOrApiKey::ApiKey(key) => format!("ApiKey {}", key.id),
},
);
if let Some(group) = group {
request = request.header("Group", &group.id);
}
let response = request
.json(&json!({
"at": at,
"days": options.days,
"hours": options.hours,
"units": options.units,
}))
.send()
.await?;
Ok(ok(response).await?.json().await?)
}
pub async fn create_tile_pass(
authorization: &CredentialsOrApiKey,
options: &TilePassOptions,
group: Option<&Group>,
) -> Result<TilePass> {
let mut request = client()
.post(format!("{}/maps/tiles/pass", crate::get_url()))
.header(
"Authorization",
match authorization {
CredentialsOrApiKey::Credentials(credentials) => {
format!("Token {}", credentials.token)
}
CredentialsOrApiKey::ApiKey(key) => format!("ApiKey {}", key.id),
},
);
if let Some(group) = group {
request = request.header("Group", &group.id);
}
let response = request
.json(&json!({
"theme": options.theme,
"tiles": options.tiles,
"language": options.language,
"region": options.region,
}))
.send()
.await?;
Ok(ok(response).await?.json().await?)
}
pub fn get_tile_url(pass: &TilePass) -> String {
format!(
"{}/maps/tile?pass={}&z={{z}}&x={{x}}&y={{y}}",
crate::get_url(),
encode(&pass.id)
)
}
pub async fn get_tile(
pass: &TilePass,
z: u32,
x: u32,
y: u32,
on_loaded: Option<impl Fn(u64)>,
) -> Result<Vec<u8>> {
let response = client()
.get(format!(
"{}/maps/tile?pass={}&z={z}&x={x}&y={y}",
crate::get_url(),
encode(&pass.id)
))
.send()
.await?;
let response = ok(response).await?;
let mut buffer = Vec::new();
let mut loaded = 0u64;
let mut body = response.bytes_stream();
while let Some(chunk) = body.next().await {
let chunk = chunk?;
loaded += chunk.len() as u64;
buffer.extend_from_slice(&chunk);
if let Some(on_loaded) = &on_loaded {
on_loaded(loaded);
}
}
Ok(buffer)
}
pub async fn get_attribution(pass: &TilePass, zoom: u32, bounds: &Bounds) -> Result<Attribution> {
let response = client()
.get(format!(
"{}/maps/tiles/attribution?pass={}&zoom={zoom}&north={}&south={}&east={}&west={}",
crate::get_url(),
encode(&pass.id),
bounds.north,
bounds.south,
bounds.east,
bounds.west
))
.send()
.await?;
Ok(ok(response).await?.json().await?)
}