voyager_client 0.3.6

Crate that contains base clients for interacting with the NASA Open APIs
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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

use crate::prelude::{Client, Params};
use std::error::Error;

#[doc = "Parameters for the Earth API"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct EarthParams<'p>
{
    #[doc = "Latitude of the location"]
    pub lat: f64,
    #[doc = "Longitude of the location"]
    pub lon: f64,
    #[doc = "Dimension of the image (Optional)"]
    pub dim: Option<f64>,
    #[doc = "Date of the image (Optional)"]
    pub date: Option<&'p str>,
    #[doc = "Include cloud score in the response (Optional)"]
    pub cloud_score: Option<bool>,
}

impl<'p> Default for EarthParams<'p>
{
    fn default() -> Self
    {
        Self {
            lat: 0.0,
            lon: 0.0,
            dim: None,
            date: None,
            cloud_score: None,
        }
    }
}

#[allow(missing_docs)]
impl<'p> EarthParams<'p>
{
    pub fn new() -> Self { Self::default() }

    pub fn lat(mut self, lat: f64) -> Self
    {
        self.lat = lat;
        return self;
    }

    pub fn lon(mut self, lon: f64) -> Self
    {
        self.lon = lon;
        return self;
    }

    pub fn dim(mut self, dim: f64) -> Self
    {
        self.dim = Some(dim);
        return self;
    }

    pub fn date(mut self, date: &'p str) -> Self
    {
        self.date = Some(date);
        return self;
    }

    pub fn cloud_score(mut self, cloud_score: bool) -> Self
    {
        self.cloud_score = Some(cloud_score);
        return self;
    }
}

impl<'p> Into<String> for EarthParams<'p>
{
    fn into(self) -> String
    {
        let mut params = String::new();
        params.push_str(&format!("lat={}", self.lat));
        params.push_str(&format!("&lon={}", self.lon));

        if let Some(dim) = self.dim
        {
            params.push_str(&format!("&dim={}", dim));
        }
        if let Some(date) = self.date
        {
            params.push_str(&format!("&date={}", date));
        }
        if let Some(cloud_score) = self.cloud_score
        {
            params.push_str(&format!("&cloud_score={}", cloud_score));
        }

        return params;
    }
}

impl<'p> Params for EarthParams<'p> {}

#[allow(missing_docs)]
#[derive(Clone, Debug)]
pub struct Earth {}

impl Default for Earth
{
    fn default() -> Self { Self {} }
}

#[allow(missing_docs)]
impl Earth
{
    pub fn new() -> Self { return Self::default() }
}

impl<'p, PARA> Client<PARA> for Earth
where
    PARA: Params,
{
    const BASE_URL: &'static str = "https://api.nasa.gov/planetary/earth/imagery";
    type Response = serde_json::Value;

    fn get(&self, params: PARA) -> Result<Self::Response, Box<dyn Error>>
    {
        let base_url = <Earth as Client<PARA>>::BASE_URL;
        let url_with_params = format!("{}?{}", base_url, params.into());
        let url_with_key = crate::prelude::keys::include(&url_with_params)?;
        let response = ureq::get(&url_with_key).call()?;
        let json = serde_json::json!(response.into_string()?);
        return Ok(json);
    }
}

#[cfg(test)]
mod earth_tests
{
    use super::*;

    #[test]
    fn test_earth()
    {
        let earth = Earth::default();
        let params = EarthParams::default();
        let response = earth.get(params);
        match response
        {
            Ok(json) => println!("{:#?}", json),
            Err(e) =>
            {
                println!("{:#?}", e);
                panic!()
            }
        }
    }
}