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

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

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


pub struct HistoryApi<'a, Tz: TimeZone> 
where
    Tz::Offset: Display
{
    client: &'a Client,
    query: Option<Query>,
    dt: Option<DateTime<Tz>>,
    end_dt: Option<DateTime<Tz>>,
    hour: bool,
    lang: Option<Language>
}

impl<'a, Tz: TimeZone> HistoryApi<'a, Tz>
where
    Tz::Offset: Display,
{
    /// Use [`crate::Client`]
    pub fn new(client: &'a Client) -> Self {
        Self {
            client,
            query: None,
            dt: None,
            end_dt: None,
            hour: 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 datetime
    /// 
    /// `dt` should be on or after 1st Jan, 2010
    pub fn dt(mut self, dt: DateTime<Tz>) -> Self {
        self.dt = Some(dt);
        self
    }

    /// Set up a end datetime
    /// 
    /// `end_dt` should be on or after 1st Jan, 2010 and should be greater than `dt` parameter and difference should not be more than 30 days between the two dates.
    pub fn end_dt(mut self, end_dt: DateTime<Tz>) -> Self {
        self.end_dt = Some(end_dt);
        self
    }

    /// Set up use hour
    /// 
    /// Time is extracted from dt
    pub fn hour(mut self) -> Self {
        self.hour = 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 HistoryApi<'a, Tz> 
where
    Tz::Offset: Display,
{
    type Model = History;

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

    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"))), 
        ];

        if let Some(end_dt) = &self.end_dt {
            params.push(("end_dt", format!("{}", end_dt.format("%Y-%m-%d"))))
        }
        
        if self.hour {
            params.push(("hour", dt.hour().to_string()))
        }

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

        params
    }
}