nullnet-libipinfo 0.2.1

IP information library for NullNet
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

use crate::IpInfo;
use crate::api::api_fields::ApiFields;
use nullnet_liberror::{Error, ErrorHandler, Location, location};
use reqwest::Client;
use serde_json::Value;

pub(crate) struct ApiConfig {
    url: String,
    fields: ApiFields,
}

impl ApiConfig {
    pub(crate) fn new(url: &str, api_key: &str, fields: ApiFields) -> Self {
        let url = url.replace("{api_key}", api_key);
        Self { url, fields }
    }

    fn get_url(&self, ip: &str) -> String {
        self.url.replace("{ip}", ip)
    }

    fn get_field_names(&self) -> &ApiFields {
        &self.fields
    }

    pub(crate) async fn lookup_ip(&self, client: &Client, ip: &str) -> Result<IpInfo, Error> {
        let json: Value = client
            .get(self.get_url(ip))
            .send()
            .await
            .handle_err(location!())?
            .json()
            .await
            .handle_err(location!())?;

        let names = self.get_field_names();

        Ok(IpInfo {
            country: names.extract_country(&json),
            asn: names.extract_asn(&json),
            org: names.extract_org(&json),
            continent_code: names.extract_continent_code(&json),
            city: names.extract_city(&json),
            region: names.extract_region(&json),
            postal: names.extract_postal(&json),
            timezone: names.extract_timezone(&json),
        })
    }
}

#[cfg(test)]
mod tests {
    use crate::IpInfo;
    use crate::api::api_config::ApiConfig;
    use crate::api::api_fields::ApiFields;
    use crate::web_client::new_web_client;

    #[tokio::test]
    async fn test_lookup_from_api() {
        let api_provider = ApiConfig::new(
            "https://ipapi.co/{ip}/json",
            "",
            ApiFields {
                country: Some("/country"),
                asn: Some("/asn"),
                org: Some("/org"),
                continent_code: Some("/continent_code"),
                city: Some("/city"),
                region: Some("/region"),
                postal: Some("/postal"),
                timezone: Some("/timezone"),
            },
        );

        let ip_info = api_provider
            .lookup_ip(&new_web_client().unwrap(), "8.8.8.8")
            .await
            .unwrap();
        assert_eq!(
            ip_info,
            IpInfo {
                country: Some("US".to_string()),
                asn: Some("AS15169".to_string()),
                org: Some("GOOGLE".to_string()),
                continent_code: Some("NA".to_string()),
                city: Some("Mountain View".to_string()),
                region: Some("California".to_string()),
                postal: Some("94043".to_string()),
                timezone: Some("America/Los_Angeles".to_string())
            }
        );
    }
}