weer_api 0.1.1

A wrapper library for using Weather 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

use std::fmt::Display;
use chrono::{DateTime, TimeZone, Timelike};

use super::BaseApi;
use crate::{Client, Query, Language, Forecast};


pub struct ForecastApi<'a, Tz: TimeZone> 
where
    Tz::Offset: Display
{
    client: &'a Client,
    query: Option<Query>,
    days: Option<u8>,
    dt: Option<DateTime<Tz>>,
    hour: bool,
    alerts: bool,
    aqi: bool,
    lang: Option<Language>
}

impl<'a, Tz: TimeZone> ForecastApi<'a, Tz>
where
    Tz::Offset: Display,
{
    /// Use [`crate::Client`]
    pub fn new(client: &'a Client) -> Self {
        Self {
            client,
            query: None,
            days: None,
            dt: None,
            hour: false,
            alerts: false,
            aqi: false,
            lang: None
        }
    }

    /// Set up the query
    /// 
    /// Query parameter based on which data is sent back
    pub fn query(mut self, query: Query) -> Self {
        self.query = Some(query);
        self
    }

    /// Set up a days
    /// 
    /// Days parameter value ranges between 1 and 14. e.g: days=5
    /// 
    /// If no days parameter is provided then only today's weather is returned. 
    pub fn days(mut self, days: u8) -> Self {
        self.days = Some(days);
        self
    }

    /// Set up a datetime
    /// 
    /// `dt` should be between today and next 14 day 
    pub fn dt(mut self, dt: DateTime<Tz>) -> Self {
        self.dt = Some(dt);
        self
    }

    /// Set up use hour
    /// 
    /// Time is extracted from dt
    pub fn hour(mut self) -> Self {
        self.hour = true;
        self
    }

    /// Set up alerts
    pub fn alerts(mut self) -> Self {
        self.alerts = true;
        self
    }

    /// Set up Air Quality Data
    /// 
    /// Air quality data is not passed by default.
    pub fn aqi(mut self) -> Self {
        self.aqi = true;
        self
    }

    /// Set up language 
    /// 
    /// `condition:text` field in API in the desired language
    pub fn lang(mut self, lang: Language) -> Self {
        self.lang = Some(lang);
        self
    }
}

impl<'a, Tz: TimeZone> BaseApi<'a> for ForecastApi<'a, Tz> 
where
    Tz::Offset: Display,
{
    type Model = Forecast;

    fn path(&self) -> &str {
        "forecast"
    }

    fn client(&self) -> &'a Client {
        self.client
    }

    fn params(&self) -> Vec<(&str, String)> {
        let query = self.query.as_ref().unwrap();
        let dt = self.dt.as_ref().unwrap();

        let mut params = vec![
            ("key", self.client.api_key.clone()), ("q", query.to_string()), ("dt", format!("{}", dt.format("%Y-%m-%d"))), 
            ("alerts", if self.alerts { "yes".to_string() } else { "no".to_string() }),
            ("aqi", if self.aqi { "yes".to_string() } else { "no".to_string() })
        ];
        
        if let Some(days) = self.days {
            params.push(("days", days.to_string()))
        }

        if self.hour {
            params.push(("hour", dt.hour().to_string()))
        }

        if let Some(lang) = &self.lang {
            params.push(("lang", lang.to_string()))
        }

        params
    }
}