airlabs-client 0.0.1

airlabs.co API client library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

use std::time;

use airlabs_api as api;
use serde_json as json;

pub use error::Error;
pub use response::Response;
pub use response::TypedResponse;

mod error;
mod response;

#[derive(Debug)]
pub struct Client {
    base: String,
    client: reqwest::Client,
    key: String,
    free_account: bool,
}

impl Client {
    pub fn new(key: impl ToString) -> Self {
        let base = "https://airlabs.co/api/v9".to_string();
        let key = key.to_string();
        let client = reqwest::Client::new();
        let free_account = false;
        Self {
            base,
            client,
            key,
            free_account,
        }
    }

    pub fn update_from_ping(self, ping: Response) -> json::Result<Self> {
        let free_account = ping
            .api_response::<api::Pong>()?
            .request
            .is_some_and(|request| request.is_free());
        Ok(Self {
            free_account,
            ..self
        })
    }

    pub fn is_free(&self) -> bool {
        self.free_account
    }

    pub async fn ping(&self) -> reqwest::Result<Response> {
        let request = api::PingRequest {
            api_key: self.key.clone(),
        };
        self.post(request).await
    }

    pub async fn airlines(&self) -> reqwest::Result<Response> {
        let request = api::AirlinesRequest::new(&self.key);
        self.get(request).await
    }

    pub async fn airports(&self) -> reqwest::Result<Response> {
        let request = api::AirportsRequest::new(&self.key);
        self.get(request).await
    }

    pub async fn flight_iata(&self, code: impl ToString) -> reqwest::Result<Response> {
        let request = api::FlightRequest::iata(&self.key, code);
        self.get(request).await
    }

    pub async fn flight_icao(&self, code: impl ToString) -> reqwest::Result<Response> {
        let request = api::FlightRequest::icao(&self.key, code);
        self.get(request).await
    }

    pub async fn get<R>(&self, request: R) -> reqwest::Result<Response>
    where
        R: api::AirLabsRequest + serde::Serialize,
    {
        let start = time::Instant::now();
        let request = self.get_request(request);
        request
            .send()
            .await?
            .error_for_status()?
            .text()
            .await
            .map(|raw| Response::new(raw, start.elapsed()))
    }

    async fn post<R>(&self, request: R) -> reqwest::Result<Response>
    where
        R: api::AirLabsRequest + serde::Serialize,
    {
        let start = time::Instant::now();
        let request = self.post_request(request);
        request
            .send()
            .await?
            .error_for_status()?
            .text()
            .await
            .map(|raw| Response::new(raw, start.elapsed()))
    }

    fn get_request<R>(&self, request: R) -> reqwest::RequestBuilder
    where
        R: api::AirLabsRequest + serde::Serialize,
    {
        let url = self.url(&request);
        self.client.get(url).query(&request)
    }

    fn post_request<R>(&self, request: R) -> reqwest::RequestBuilder
    where
        R: api::AirLabsRequest + serde::Serialize,
    {
        let url = self.url(&request);
        self.client.post(url).json(&request)
    }

    fn url<T>(&self, request: &T) -> String
    where
        T: api::AirLabsRequest,
    {
        request.url(&self.base)
    }
}

#[cfg(test)]
mod tests;