razberry 0.3.0

An HTTP client library for the Razberry Z-Wave Hub
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

// Copyright (c) 2017 Brandon Thomas <bt@brand.io, echelon@gmail.com>

use error::RazberryError;
use rustc_serialize::json::Json;
use std::collections::HashMap;

/**
 * A single update from a single device. There may be many per refresh.
 *
 * Given a key of the form,
 *   devices.14.instances.0.commandClasses.32.data.srcNodeId
 *
 * We parse out,
 *   device_id = "14"
 *   path = (instances, 0, commandClasses, 32, data, srcNodeId)
 *   data = JSON that lives under that key.
 */
pub struct DeviceUpdate<'a> {
  pub path: Vec<&'a str>,
  pub data: &'a Json,
}

impl <'a> DeviceUpdate<'a> {
  /// Parse the update JSON payload and return a list of device updates, grouped
  /// by device identifier.
  pub fn parse_updates(json: &'a Json)
      -> Result<HashMap<String, Vec<DeviceUpdate<'a>>>, RazberryError> {
    let json = json.as_object()
        .ok_or(RazberryError::BadResponse)?;

    let mut all_updates = HashMap::new();

    for (update_key, update_value) in json {
      if !update_key.starts_with("devices.") {
        // Everything was dumped into the top-level keyspace.
        // We only want device updates.
        continue;
      }

      // Split by dot-component, skip "devices" and keep the device number
      let mut split = update_key.split(".");
      let _r = split.next().ok_or(RazberryError::BadResponse)?; // skip
      let device_id = split.next().ok_or(RazberryError::BadResponse)?;
      let path = split.collect::<Vec<&str>>();

      let update = DeviceUpdate {
        path: path,
        data: update_value,
      };

      let device_updates = all_updates.entry(device_id.to_string())
          .or_insert_with(|| Vec::new());

      device_updates.push(update);
    }

    Ok(all_updates)
  }
}

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

  #[test]
  fn test_parse() {
    let json = Json::from_str(r#"
      {
        "devices.1.instances.0.commandClasses.32.data.level": {
          "value": 255,
          "type": "int",
          "invalidateTime": 1491741863,
          "updateTime": 1492409902
        },
        "devices.1.instances.0.commandClasses.32.data.srcNodeId": {
          "value": 9,
          "type": "int",
          "invalidateTime": 1491741863,
          "updateTime": 1492409902
        },
        "devices.1.instances.0.commandClasses.32.data.srcInstanceId": {
          "value": 0,
          "type": "int",
          "invalidateTime": 1491741863,
          "updateTime": 1492409902
        },
        "devices.9.data.lastReceived": {
          "value": 0,
          "type": "int",
          "invalidateTime": 1465266282,
          "updateTime": 1492409902
        },
        "devices.9.instances.0.commandClasses.48.data.1": {
          "value": null,
          "type": "empty",
          "sensorTypeString": {
            "value": "General purpose",
            "type": "string",
            "invalidateTime": 1487401953,
            "updateTime": 1487401954
          },
          "level": {
            "value": true,
            "type": "bool",
            "invalidateTime": 1489636200,
            "updateTime": 1492409902
          },
          "invalidateTime": 1487401953,
          "updateTime": 1492409902
        },
        "updateTime": 1492409924
      }
    "#).unwrap();

    let updates = DeviceUpdate::parse_updates(&json).unwrap();

    // Assert devices within the update
    assert!(updates.contains_key("1"));
    assert!(updates.contains_key("9"));

    // Assert updates for first device.
    assert_eq!(3, updates.get("1").unwrap().len());

    assert_eq!(vec!["instances", "0", "commandClasses", "32", "data", "level"],
      updates.get("1").unwrap().get(0).unwrap().path);

    // Assert updates for second device.
    assert_eq!(2, updates.get("9").unwrap().len());

    assert_eq!(vec!["data", "lastReceived"],
      updates.get("9").unwrap().get(0).unwrap().path);

    assert_eq!(vec!["instances", "0", "commandClasses", "48", "data", "1"],
      updates.get("9").unwrap().get(1).unwrap().path);

    // TODO: Assert JSON payloads
  }
}