fauna-api 1.0.786

The Fauna SDK for Rust: accounts, Drive, groups, calendar, chats, payments, Parrot and live rooms.
Documentation
use serde::{Deserialize, Serialize};
use serde_json::json;

use crate::authentification::CredentialsOrApiKey;
use crate::error::Result;
use crate::groups::Group;
use crate::http::{client, ok};
use crate::maps::{Coordinates, Money, Waypoint};

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum Cabin {
    Economy,
    Premium,
    Business,
    First,
}

/// One way flights between two airports (IATA codes, or several joined with
/// commas) on a local date.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct FlightQuery {
    pub from: String,
    pub to: String,
    /// YYYY-MM-DD.
    pub date: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub adults: Option<u32>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub cabin: Option<Cabin>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub currency: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max: Option<u32>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FlightStop {
    pub code: String,
    pub name: String,
}

/// Times are local to each airport, YYYY-MM-DDTHH:mm.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FlightLeg {
    pub airline: String,
    pub number: String,
    pub from: FlightStop,
    pub to: FlightStop,
    pub departure: String,
    pub arrival: String,
    /// Seconds.
    pub duration: f64,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub aircraft: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub logo: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Flight {
    pub id: String,
    pub price: Money,
    /// Seconds, layovers included.
    pub duration: f64,
    pub stops: u32,
    pub from: String,
    pub to: String,
    pub departure: String,
    pub arrival: String,
    pub airlines: Vec<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub logo: Option<String>,
    pub legs: Vec<FlightLeg>,
}

/// Somewhere to book. When `form` is set, POST it to `url` as a url encoded
/// form instead of opening `url`.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Offer {
    pub seller: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub price: Option<Money>,
    pub url: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub form: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub logo: Option<String>,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum HotelSort {
    Relevance,
    Price,
    Rating,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct HotelQuery {
    pub near: Waypoint,
    /// YYYY-MM-DD.
    pub check_in: String,
    /// YYYY-MM-DD.
    pub check_out: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub adults: Option<u32>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub currency: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub max: Option<u32>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub sort: Option<HotelSort>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Hotel {
    pub id: String,
    pub name: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub address: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub coordinates: Option<Coordinates>,
    /// Out of 5.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub rating: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub reviews: Option<u32>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub stars: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub nightly: Option<Money>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub total: Option<Money>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub image: Option<String>,
    #[serde(default)]
    pub amenities: Vec<String>,
    #[serde(default)]
    pub offers: Vec<Offer>,
}

pub async fn search_flights(
    authorization: &CredentialsOrApiKey,
    query: &FlightQuery,
    group: Option<&Group>,
) -> Result<Vec<Flight>> {
    let mut request = client()
        .post(format!("{}/travel/flights", 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?)
}

/// Where a flight can be booked, and for how much.
pub async fn get_offers(
    authorization: &CredentialsOrApiKey,
    flight: &Flight,
    group: Option<&Group>,
) -> Result<Vec<Offer>> {
    let mut request = client()
        .post(format!("{}/travel/flights/offers", 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!({ "id": flight.id })).send().await?;
    Ok(ok(response).await?.json().await?)
}

pub async fn search_hotels(
    authorization: &CredentialsOrApiKey,
    query: &HotelQuery,
    group: Option<&Group>,
) -> Result<Vec<Hotel>> {
    let mut request = client()
        .post(format!("{}/travel/hotels", 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?)
}