Skip to main content

fauna_api/
travel.rs

1use serde::{Deserialize, Serialize};
2use serde_json::json;
3
4use crate::authentification::CredentialsOrApiKey;
5use crate::error::Result;
6use crate::groups::Group;
7use crate::http::{client, ok};
8use crate::maps::{Coordinates, Money, Waypoint};
9
10#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
11#[serde(rename_all = "lowercase")]
12pub enum Cabin {
13    Economy,
14    Premium,
15    Business,
16    First,
17}
18
19/// One way flights between two airports (IATA codes, or several joined with
20/// commas) on a local date.
21#[derive(Debug, Clone, Default, Serialize, Deserialize)]
22pub struct FlightQuery {
23    pub from: String,
24    pub to: String,
25    /// YYYY-MM-DD.
26    pub date: String,
27    #[serde(default, skip_serializing_if = "Option::is_none")]
28    pub adults: Option<u32>,
29    #[serde(default, skip_serializing_if = "Option::is_none")]
30    pub cabin: Option<Cabin>,
31    #[serde(default, skip_serializing_if = "Option::is_none")]
32    pub currency: Option<String>,
33    #[serde(default, skip_serializing_if = "Option::is_none")]
34    pub max: Option<u32>,
35}
36
37#[derive(Debug, Clone, Serialize, Deserialize)]
38pub struct FlightStop {
39    pub code: String,
40    pub name: String,
41}
42
43/// Times are local to each airport, YYYY-MM-DDTHH:mm.
44#[derive(Debug, Clone, Serialize, Deserialize)]
45pub struct FlightLeg {
46    pub airline: String,
47    pub number: String,
48    pub from: FlightStop,
49    pub to: FlightStop,
50    pub departure: String,
51    pub arrival: String,
52    /// Seconds.
53    pub duration: f64,
54    #[serde(default, skip_serializing_if = "Option::is_none")]
55    pub aircraft: Option<String>,
56    #[serde(default, skip_serializing_if = "Option::is_none")]
57    pub logo: Option<String>,
58}
59
60#[derive(Debug, Clone, Serialize, Deserialize)]
61pub struct Flight {
62    pub id: String,
63    pub price: Money,
64    /// Seconds, layovers included.
65    pub duration: f64,
66    pub stops: u32,
67    pub from: String,
68    pub to: String,
69    pub departure: String,
70    pub arrival: String,
71    pub airlines: Vec<String>,
72    #[serde(default, skip_serializing_if = "Option::is_none")]
73    pub logo: Option<String>,
74    pub legs: Vec<FlightLeg>,
75}
76
77/// Somewhere to book. When `form` is set, POST it to `url` as a url encoded
78/// form instead of opening `url`.
79#[derive(Debug, Clone, Serialize, Deserialize)]
80pub struct Offer {
81    pub seller: String,
82    #[serde(default, skip_serializing_if = "Option::is_none")]
83    pub price: Option<Money>,
84    pub url: String,
85    #[serde(default, skip_serializing_if = "Option::is_none")]
86    pub form: Option<String>,
87    #[serde(default, skip_serializing_if = "Option::is_none")]
88    pub logo: Option<String>,
89}
90
91#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
92#[serde(rename_all = "lowercase")]
93pub enum HotelSort {
94    Relevance,
95    Price,
96    Rating,
97}
98
99#[derive(Debug, Clone, Default, Serialize, Deserialize)]
100#[serde(rename_all = "camelCase")]
101pub struct HotelQuery {
102    pub near: Waypoint,
103    /// YYYY-MM-DD.
104    pub check_in: String,
105    /// YYYY-MM-DD.
106    pub check_out: String,
107    #[serde(default, skip_serializing_if = "Option::is_none")]
108    pub adults: Option<u32>,
109    #[serde(default, skip_serializing_if = "Option::is_none")]
110    pub currency: Option<String>,
111    #[serde(default, skip_serializing_if = "Option::is_none")]
112    pub max: Option<u32>,
113    #[serde(default, skip_serializing_if = "Option::is_none")]
114    pub sort: Option<HotelSort>,
115}
116
117#[derive(Debug, Clone, Serialize, Deserialize)]
118pub struct Hotel {
119    pub id: String,
120    pub name: String,
121    #[serde(default, skip_serializing_if = "Option::is_none")]
122    pub address: Option<String>,
123    #[serde(default, skip_serializing_if = "Option::is_none")]
124    pub coordinates: Option<Coordinates>,
125    /// Out of 5.
126    #[serde(default, skip_serializing_if = "Option::is_none")]
127    pub rating: Option<f64>,
128    #[serde(default, skip_serializing_if = "Option::is_none")]
129    pub reviews: Option<u32>,
130    #[serde(default, skip_serializing_if = "Option::is_none")]
131    pub stars: Option<f64>,
132    #[serde(default, skip_serializing_if = "Option::is_none")]
133    pub nightly: Option<Money>,
134    #[serde(default, skip_serializing_if = "Option::is_none")]
135    pub total: Option<Money>,
136    #[serde(default, skip_serializing_if = "Option::is_none")]
137    pub image: Option<String>,
138    #[serde(default)]
139    pub amenities: Vec<String>,
140    #[serde(default)]
141    pub offers: Vec<Offer>,
142}
143
144pub async fn search_flights(
145    authorization: &CredentialsOrApiKey,
146    query: &FlightQuery,
147    group: Option<&Group>,
148) -> Result<Vec<Flight>> {
149    let mut request = client()
150        .post(format!("{}/travel/flights", crate::get_url()))
151        .header(
152            "Authorization",
153            match authorization {
154                CredentialsOrApiKey::Credentials(credentials) => {
155                    format!("Token {}", credentials.token)
156                }
157                CredentialsOrApiKey::ApiKey(key) => format!("ApiKey {}", key.id),
158            },
159        );
160    if let Some(group) = group {
161        request = request.header("Group", &group.id);
162    }
163    let response = request.json(&json!({ "query": query })).send().await?;
164    Ok(ok(response).await?.json().await?)
165}
166
167/// Where a flight can be booked, and for how much.
168pub async fn get_offers(
169    authorization: &CredentialsOrApiKey,
170    flight: &Flight,
171    group: Option<&Group>,
172) -> Result<Vec<Offer>> {
173    let mut request = client()
174        .post(format!("{}/travel/flights/offers", crate::get_url()))
175        .header(
176            "Authorization",
177            match authorization {
178                CredentialsOrApiKey::Credentials(credentials) => {
179                    format!("Token {}", credentials.token)
180                }
181                CredentialsOrApiKey::ApiKey(key) => format!("ApiKey {}", key.id),
182            },
183        );
184    if let Some(group) = group {
185        request = request.header("Group", &group.id);
186    }
187    let response = request.json(&json!({ "id": flight.id })).send().await?;
188    Ok(ok(response).await?.json().await?)
189}
190
191pub async fn search_hotels(
192    authorization: &CredentialsOrApiKey,
193    query: &HotelQuery,
194    group: Option<&Group>,
195) -> Result<Vec<Hotel>> {
196    let mut request = client()
197        .post(format!("{}/travel/hotels", crate::get_url()))
198        .header(
199            "Authorization",
200            match authorization {
201                CredentialsOrApiKey::Credentials(credentials) => {
202                    format!("Token {}", credentials.token)
203                }
204                CredentialsOrApiKey::ApiKey(key) => format!("ApiKey {}", key.id),
205            },
206        );
207    if let Some(group) = group {
208        request = request.header("Group", &group.id);
209    }
210    let response = request.json(&json!({ "query": query })).send().await?;
211    Ok(ok(response).await?.json().await?)
212}