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

use crate::calendar_history::{HistoryKind, HistoryPeriod};
use crate::energy::GatewayId;
use crate::{get_arg, get_args, join_query_pairs, rfc3339, Api, Values};
use chrono::{DateTime, FixedOffset};
use derive_more::{Display, FromStr};
use serde::{Deserialize, Serialize};

#[rustfmt::skip]
impl Api {
    get_arg!(powerwall_status, PowerwallStatus, "/powerwalls/{}/status", PowerwallId);
    get_args!(powerwall_energy_history, PowerwallEnergyHistory, "/powerwalls/{}/energyhistory", PowerwallEnergyHistoryValues);
}

#[derive(Debug, Clone, Serialize, Deserialize, Display, FromStr)]
pub struct PowerwallId(pub String);

#[derive(Debug, Clone, Deserialize)]
pub struct PowerwallStatus {
    pub site_name: String,
    pub id: GatewayId,
    pub energy_left: f64,
    pub total_pack_energy: i64,
    pub percentage_charged: f64,
    pub battery_power: i64,
}

#[derive(Debug, Clone)]
pub struct PowerwallEnergyHistoryValues {
    pub powerwall_id: PowerwallId,
    pub period: HistoryPeriod,
    pub kind: HistoryKind,
    pub start_date: Option<DateTime<FixedOffset>>,
    pub end_date: Option<DateTime<FixedOffset>>,
}

impl Values for PowerwallEnergyHistoryValues {
    fn format(&self, url: &str) -> String {
        let url = url.replace("{}", &self.powerwall_id.0.to_string());
        let mut pairs: Vec<(&str, String)> = vec![
            ("period", self.period.to_string()),
            ("kind", self.kind.to_string()),
        ];
        if let Some(start_date) = self.start_date {
            let start_date = rfc3339(&start_date);
            pairs.push(("start_date", start_date));
        }
        if let Some(end_date) = self.end_date {
            let end_date = rfc3339(&end_date);
            pairs.push(("end_date", end_date));
        }
        format!("{}?{}", url, join_query_pairs(&pairs))
    }
}

#[derive(Debug, Clone, Deserialize)]
pub struct PowerwallEnergyHistory {}