yngvi 0.4.3

Read, calculate and write weather data
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

use crate::core::WeatherReading;
use reqwest::Client;
use std::future::Future;

pub trait Writer {
    fn write(&mut self, weather_reading: &WeatherReading) -> impl Future<Output = Result<(), ()>>;
}

impl<T: Writer + ?Sized + Send> Writer for Box<T> {
    async fn write(&mut self, weather_reading: &WeatherReading) -> Result<(), ()> {
        (**self).write(&weather_reading).await
    }
}

pub struct StdoutWriter;

impl StdoutWriter {
    pub fn new() -> Self {
        Self {}
    }
}

impl Writer for StdoutWriter {
    async fn write(&mut self, weather_reading: &WeatherReading) -> Result<(), ()> {
        if let Ok(json) = serde_json::to_string(weather_reading) {
            println!("{}", json);
        }

        Ok(())
    }
}

pub struct InMemWriter {
    pub readings: Vec<WeatherReading>,
}

impl InMemWriter {
    pub fn new() -> Self {
        Self { readings: vec![] }
    }
}

impl Writer for InMemWriter {
    async fn write(&mut self, weather_reading: &WeatherReading) -> Result<(), ()> {
        self.readings.push(weather_reading.clone());

        Ok(())
    }
}

pub struct NoopWriter {}

impl NoopWriter {
    pub fn new() -> Self {
        Self {}
    }
}

impl Writer for NoopWriter {
    async fn write(&mut self, _: &WeatherReading) -> Result<(), ()> {
        Ok(())
    }
}

pub struct WebhookWriter {
    pub url: String,
    pub client: Client,
    pub headers: Vec<(String, String)>,
}

impl WebhookWriter {
    pub fn new(url: String, headers: Vec<(String, String)>) -> Self {
        Self {
            url: url.to_string(),
            client: Client::new(),
            headers,
        }
    }
}

impl Writer for WebhookWriter {
    async fn write(&mut self, weather_reading: &WeatherReading) -> Result<(), ()> {
        let mut request = self
            .client
            .post(&self.url)
            .header("Content-Type", "application/json")
            .json(weather_reading);

        for header in &self.headers {
            request = request.header(&header.0, &header.1);
        }

        if let Ok(response) = request.send().await {
            if response.status() == 204 {
                Ok(())
            } else {
                Err(())
            }
        } else {
            Err(())
        }
    }
}