openweather-async 0.1.2

An async library for use with the openweathermap.org API
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
133
134
135

pub use crate::units::*;
pub use crate::models::*;
use std::error::Error;


pub struct OpenWeather {
    pub api_key: String,
    pub units: Units,
}


impl OpenWeather {

    pub async fn new(
        api_key: &str,
        units: Units
    ) -> Result<OpenWeather, Box<dyn std::error::Error>> {
        Ok(OpenWeather {
            api_key: api_key.to_string(),
            units: units,
        })
    }

    async fn get_multiple(
        &self,
        query: String
    ) -> Result<WeatherMultiple, Box<dyn Error>> {
        let addr = self.format_addr(query).await?;
        println!("{:?}", addr);
        let response = self.get_response(&addr).await?;
        println!("{:?}", response);
        let data = self.parse_json_multiple(&response).await?;
        Ok(data)
    }

    pub async fn get_by_city(
        &self,
        city: &str
    ) -> Result<Weather, Box<dyn Error>> {
        self.get(format!("weather?q={}", &city)).await
    }


    pub async fn get_by_city_and_country(
        &self,
        city: &str,
        country: &str
    ) -> Result<Weather, Box<dyn Error>> {
        self.get(format!("weather?q={},{}", &city, &country)).await
    }

    pub async fn get_by_coordinates(
        &self,
        lat: f32,
        lon: f32
    ) -> Result<Weather, Box<dyn Error>> {
        self.get(format!("weather?lat={}&lon={}", lat, lon)).await
    }

    pub async fn get_by_zipcode(
        &self,
        zipcode: u32,
        country: &str,
    ) -> Result<Weather, Box<dyn Error>> {
        self.get(format!("weather?q={},{}", zipcode, country)).await
    }

    pub async fn get_by_cities_in_zone(
        &self,
        lon1: f32,
        lat1: f32,
        lon2: f32,
        lat2: f32,
        zoom: u32,
    ) -> Result<WeatherMultiple, Box<dyn Error>> {
        self.get_multiple(format!("box/city?bbox={},{},{},{},{}", lon1, lat1, lon2, lat2, zoom)).await
    }

    pub async fn get_by_cities_in_cycle(
        &self,
        lon: f32,
        lat: f32,
        count: u32,
    ) -> Result<WeatherMultiple, Box<dyn Error>> {
        self.get_multiple(format!("find?lat={}&lon={}&cnt={}", lon, lat, count)).await
    }

    async fn get(
        &self,
        query: String
    ) -> Result<Weather, Box<dyn Error>> {
        let addr = self.format_addr(query).await?;
        println!("{:?}", addr);
        let response = self.get_response(&addr).await?;
        let data = self.parse_json(&response).await?;
        Ok(data)
    }

    async fn format_addr(
        &self,
        query: String
    ) -> Result<String, Box<dyn std::error::Error>> {
        let base_http = "https://api.openweathermap.org/data/2.5/";
        Ok(format!(
            "{}{}&appid={}&units={}",
            &base_http, &query, self.api_key, self.units.value()
        ))
    }

    async fn get_response(
        &self,
        addr: &str
    ) -> Result<String, reqwest::Error> {
        let json = reqwest::get(addr).await?.text().await?;
        Ok(json)
    }

    async fn parse_json(
        &self,
        json: &str
    ) -> Result<Weather, serde_json::error::Error> {
        let data: Weather = serde_json::from_str(&json.to_string())?;
        Ok(data)
    }

    async fn parse_json_multiple(
        &self,
        json: &str
    ) -> Result<WeatherMultiple, serde_json::error::Error> {
        let data: WeatherMultiple = serde_json::from_str(&json.to_string())?;
        println!("{:?}", data);
        Ok(data)
    }

}