gecko 0.1.6

coin gecko api impl
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

//! # `/events`
//!
//! - [/events](Events)
//! - [/events/countries](Countries)
//! - [/events/types](Types)
//!
use crate::Route;

pub struct Events {
    endpoint: String,
    pub country_code: String,
    pub ev_type: String,
    pub page: i32,
    pub upcoming_events_only: bool,
    pub from_date: String, // date
    pub to_date: String,
}
pub struct Countries {
    endpoint: String,
}
pub struct Types {
    endpoint: String,
}

impl Events {
    pub fn required() -> Events {
        Events::default()
    }
}
impl Countries {
    pub fn required() -> Countries {
        Countries::default()
    }
}
impl Types {
    pub fn required() -> Types {
        Types::default()
    }
}

impl Default for Events {
    fn default() -> Events {
        Events {
            endpoint: String::from("/events"),
            country_code: String::from("US"),
            ev_type: String::from(""),
            page: 1,
            upcoming_events_only: true,
            from_date: String::from(""),
            to_date: String::from(""),
        }
    }
}
impl Default for Countries {
    fn default() -> Countries {
        Countries {
            endpoint: String::from("/events/countries"),
        }
    }
}
impl Default for Types {
    fn default() -> Types {
        Types {
            endpoint: String::from("/events/types"),
        }
    }
}

impl Route for Events {
    fn api_endpoint(&self) -> String {
        format!("{}", self.endpoint)
    }
    fn query_string(&self) -> String {
        let default: Events = Default::default();
        let country_code = self.format_query(
            "country_code".to_string(),
            &(self.country_code),
            &(default.country_code),
        );
        let ev_type = self.format_query("ev_type".to_string(), &(self.ev_type), &(default.ev_type));
        let page = self.format_query("page".to_string(), self.page, default.page);
        let upcoming_events_only = self.format_query(
            "upcoming_events_only".to_string(),
            self.upcoming_events_only,
            default.upcoming_events_only,
        );
        let from_date = self.format_query(
            "from_date".to_string(),
            &(self.from_date),
            &(default.from_date),
        );
        let to_date = self.format_query("to_date".to_string(), &(self.to_date), &(default.to_date));

        let optional = vec![
            country_code,
            ev_type,
            page,
            upcoming_events_only,
            from_date,
            to_date,
        ];
        self.collect_query_params(optional)
    }
}
impl Route for Countries {
    fn api_endpoint(&self) -> String {
        format!("{}", self.endpoint)
    }
    fn query_string(&self) -> String {
        String::from("")
    }
}
impl Route for Types {
    fn api_endpoint(&self) -> String {
        format!("{}", self.endpoint)
    }
    fn query_string(&self) -> String {
        String::from("")
    }
}