enphase 0.4.0

An async wrapper around the Enphase APIs - both direct local access to Envoy devices, and the Enlighten cloud service
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

use std::net::IpAddr;

use chrono::serde::ts_seconds;
use chrono::DateTime;
use chrono::Utc;
use compact_str::CompactString;
use macaddr::MacAddr6;
use serde::Deserialize;
use serde_with::serde_as;
use serde_with::DisplayFromStr;

#[serde_as]
#[derive(Clone, Debug, Eq, PartialEq, Deserialize)]
pub struct Home {
	#[serde(with = "ts_seconds")]
	pub software_build_epoch: DateTime<Utc>,
	pub is_nonvoy: bool,
	pub db_size: CompactString,
	#[serde_as(as = "DisplayFromStr")]
	pub db_percent_full: u8,
	pub timezone: CompactString,
	pub current_date: CompactString,
	pub current_time: CompactString,
	pub network: Network,
	pub tariff: CompactString,
	// TODO:  comm
	// TODO:  alerts
	pub update_status: CompactString
}

#[serde_as]
#[derive(Clone, Debug, Eq, PartialEq, Deserialize)]
pub struct Network {
	pub web_comm: bool,
	pub ever_reported_to_enlighten: bool,
	#[serde(with = "ts_seconds")]
	pub last_enlighten_report_time: DateTime<Utc>,
	pub primary_interface: CompactString,
	pub interfaces: Vec<Interface>
}

#[derive(Clone, Debug, Eq, PartialEq, Deserialize)]
#[serde(tag = "type")]
pub enum Interface {
	#[serde(rename = "ethernet")]
	Wired(WiredInterface),
	#[serde(rename = "wifi")]
	WiFi(WiFiInterface)
}

#[serde_as]
#[derive(Clone, Debug, Eq, PartialEq, Deserialize)]
pub struct WiredInterface {
	pub interface: CompactString,
	#[serde_as(as = "DisplayFromStr")]
	pub mac: MacAddr6,
	pub dhcp: bool,
	pub ip: IpAddr,
	//pub signal_strength: u8,
	//pub signal_strength_max: u8,
	pub carrier: bool
}

#[serde_as]
#[derive(Clone, Debug, Eq, PartialEq, Deserialize)]
pub struct WiFiInterface {
	pub interface: CompactString,
	pub signal_strength: u8,
	pub signal_strength_max: u8,
	#[serde_as(as = "DisplayFromStr")]
	pub mac: MacAddr6,
	pub dhcp: bool,
	pub ip: IpAddr,
	pub carrier: bool,
	pub supported: bool,
	pub present: bool,
	pub configured: bool,
	pub status: CompactString
}

#[cfg(test)]
mod tests {
	use chrono::TimeZone;

	use super::*;

	#[test]
	fn test_deserialize_home() {
		let s = include_str!("home/testdata/home.json");
		let home: Home = serde_json::from_str(s).unwrap();
		assert_eq!(
			home,
			Home {
				software_build_epoch: Utc.timestamp_opt(1584607493, 0).unwrap(),
				is_nonvoy: false,
				db_size: "43 MB".into(),
				db_percent_full: 11,
				timezone: "US/Eastern".into(),
				current_date: "12/12/2022".into(),
				current_time: "14:36".into(),
				network: Network {
					web_comm: true,
					ever_reported_to_enlighten: true,
					last_enlighten_report_time: Utc.timestamp_opt(1670873269, 0).unwrap(),
					primary_interface: "none".into(),
					interfaces: vec![
						Interface::Wired(WiredInterface {
							interface: "eth0".into(),
							mac: MacAddr6::new(0x00, 0x1d, 0xc0, 0x6d, 0x32, 0xc6),
							dhcp: true,
							ip: IpAddr::from([169, 254, 120, 1]),
							carrier: false
						}),
						Interface::WiFi(WiFiInterface {
							interface: "wlan0".into(),
							signal_strength: 3,
							signal_strength_max: 5,
							mac: MacAddr6::new(0x38, 0x81, 0xd7, 0x35, 0x9b, 0xd2),
							dhcp: true,
							ip: IpAddr::from([192, 168, 1, 80]),
							carrier: true,
							supported: true,
							present: true,
							configured: true,
							status: "connected".into()
						})
					]
				},
				tariff: "none".into(),
				update_status: "satisfied".into()
			}
		);
	}
}