remo 0.1.2

Nature Remo API client
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

use super::error::APIError;
use super::Client;
use serde::{Deserialize, Serialize};

#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
pub struct SensorValue {
  pub temperature: f32,
  pub humidity: f32,
  pub illumination: f32,
}

#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
pub struct Device {
  pub id: String,
  pub name: String,
  pub temperature_offset: i32,
  pub humidity_offset: i32,
  pub created_at: String,
  pub updated_at: String,
  pub firmware_version: String,
}

#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
pub struct DeviceWithEvents {
  pub id: String,
  pub name: String,
  pub temperature_offset: i32,
  pub humidity_offset: i32,
  pub created_at: String,
  pub updated_at: String,
  pub firmware_version: String,
  pub newest_events: NewestEvents,
}

#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
pub struct NewestEvents {
  pub te: EventValue,
  pub hu: EventValue,
  pub il: EventValue,
}

#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
pub struct EventValue {
  pub val: f32,
  pub created_at: String,
}

impl Client {
  pub fn get_devices(&self) -> Result<Vec<DeviceWithEvents>, APIError> {
    self.get::<Vec<DeviceWithEvents>>("/1/devices")
  }

  pub fn get_sensor_value(&self) -> Result<SensorValue, APIError> {
    let sensor_value = match self.get_devices() {
      Ok(devices) => {
        let device = &devices[0];
        SensorValue {
          temperature: device.newest_events.te.val,
          humidity: device.newest_events.hu.val,
          illumination: device.newest_events.il.val,
        }
      }
      Err(err) => return Err(err),
    };
    Ok(sensor_value)
  }
}

#[cfg(test)]
mod tests {
  use super::Client;
  use crate::tests::get_test_token;

  #[test]
  fn it_get_devices() {
    let token = get_test_token();
    let client = Client::new(Some(token));
    let res = client.get_devices().unwrap();
    println!("{:?}", res);
    assert_eq!(res[0].firmware_version, "Remo/1.0.62-gabbf5bd")
  }

  #[test]
  fn it_get_sensor_value() {
    let token = get_test_token();
    let client = Client::new(Some(token));

    let senval = client.get_sensor_value().unwrap();
    println!("{:?}", senval);
    assert!(senval.temperature > 0.0);
    assert!(senval.humidity > 0.0);
    assert!(senval.illumination > 0.0);
  }
}