use crate::energy_sites::WallConnector;
use crate::error::TeslatteError;
use crate::powerwall::PowerwallId;
use crate::vehicles::VehicleData;
use crate::{pub_get, OwnerApi};
use derive_more::Display;
use serde::{Deserialize, Deserializer, Serialize};
use serde_json::Value;
use std::str::FromStr;
#[rustfmt::skip]
impl OwnerApi {
pub_get!(products, Vec<Product>, "/products");
}
#[derive(Debug, Clone, Deserialize, Display)]
pub struct EnergySiteId(pub u64);
impl FromStr for EnergySiteId {
type Err = TeslatteError;
fn from_str(s: &str) -> Result<Self, Self::Err> {
Ok(EnergySiteId(s.parse().map_err(|_| {
TeslatteError::DecodeEnergySiteIdError(s.to_string())
})?))
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GatewayId(String);
#[derive(Debug, Clone)]
pub enum Product {
Vehicle(Box<VehicleData>),
Solar(Box<SolarData>),
Powerwall(Box<PowerwallData>),
}
fn deserialize_product<'de, D>(deserializer: D) -> Result<Product, D::Error>
where
D: Deserializer<'de>,
{
let v = Value::deserialize(deserializer)?;
if v.get("vehicle_id").is_some() {
let vehicle_data = VehicleData::deserialize(v).map_err(serde::de::Error::custom)?;
Ok(Product::Vehicle(Box::new(vehicle_data)))
} else if v.get("solar_type").is_some() {
let solar_data = SolarData::deserialize(v).map_err(serde::de::Error::custom)?;
Ok(Product::Solar(Box::new(solar_data)))
} else if v.get("battery_type").is_some() {
let powerwall_data = PowerwallData::deserialize(v).map_err(serde::de::Error::custom)?;
Ok(Product::Powerwall(Box::new(powerwall_data)))
} else {
Err(serde::de::Error::custom(
"No valid key found to determine the product type",
))
}
}
impl<'de> Deserialize<'de> for Product {
fn deserialize<D>(deserializer: D) -> Result<Product, D::Error>
where
D: Deserializer<'de>,
{
deserialize_product(deserializer)
}
}
#[derive(Debug, Clone, Deserialize)]
pub struct SolarData {
pub energy_site_id: EnergySiteId,
pub solar_type: String,
pub resource_type: String,
pub id: String,
pub asset_site_id: String,
pub solar_power: i64,
pub sync_grid_alert_enabled: bool,
pub breaker_alert_enabled: bool,
pub components: Components,
}
#[derive(Debug, Clone, Deserialize)]
pub struct PowerwallData {
pub energy_site_id: EnergySiteId,
pub battery_type: String,
pub resource_type: String,
pub site_name: String,
pub id: PowerwallId,
pub gateway_id: GatewayId,
pub asset_site_id: String,
pub percentage_charged: f64,
pub backup_capable: bool,
pub battery_power: i64,
pub sync_grid_alert_enabled: bool,
pub breaker_alert_enabled: bool,
pub components: Components,
pub powerwall_onboarding_settings_set: bool,
pub storm_mode_enabled: bool,
pub features: PowerwallFeatures,
pub warp_site_number: String,
pub go_off_grid_test_banner_enabled: Option<bool>,
pub powerwall_tesla_electric_interested_in: Option<bool>,
pub vpp_tour_enabled: Option<bool>,
}
#[derive(Debug, Clone, Deserialize)]
pub struct PowerwallFeatures {
pub rate_plan_manager_no_pricing_constraint: bool,
}
#[derive(Debug, Clone, Deserialize)]
pub struct Components {
pub battery: bool,
pub battery_type: Option<String>,
pub solar: bool,
pub solar_type: Option<String>,
pub grid: bool,
pub load_meter: bool,
pub market_type: Option<String>,
#[serde(default)]
pub wall_connectors: Vec<WallConnector>,
}
#[cfg(test)]
mod tests {
use super::*;
use crate::energy_sites::{CalendarHistoryValues, HistoryKind, HistoryPeriod};
use crate::{ApiValues, PrintResponses, RequestData};
use chrono::DateTime;
#[test]
fn energy_match_vehicle() {
let json = r#"
{
"id": 1111193485934,
"user_id": 2222291283912,
"vehicle_id": 333331238921,
"vin": "T234567890123456789",
"display_name": "My Vehicle",
"option_codes": "ASDF,SDFG,DFGH",
"color": null,
"access_type": "OWNER",
"tokens": [
"asdf1234"
],
"state": "online",
"in_service": false,
"id_s": "932423",
"calendar_enabled": true,
"api_version": 42,
"backseat_token": null,
"backseat_token_updated_at": null,
"vehicle_config": {
"aux_park_lamps": "Eu",
"badge_version": 0,
"can_accept_navigation_requests": true,
"can_actuate_trunks": true,
"car_special_type": "base",
"car_type": "model3",
"charge_port_type": "CCS",
"dashcam_clip_save_supported": true,
"default_charge_to_max": false,
"driver_assist": "TeslaAP3",
"ece_restrictions": false,
"efficiency_package": "M32026",
"eu_vehicle": true,
"exterior_color": "MidnightSilver",
"exterior_trim": "Black",
"exterior_trim_override": "",
"has_air_suspension": false,
"has_ludicrous_mode": false,
"has_seat_cooling": false,
"headlamp_type": "Global",
"interior_trim_type": "Black2",
"key_version": 2,
"motorized_charge_port": true,
"paint_color_override": "255,200,253,0.9,0.3",
"performance_package": "Base",
"plg": true,
"pws": false,
"rear_drive_unit": "T15232Z",
"rear_seat_heaters": 1,
"rear_seat_type": 0,
"rhd": true,
"roof_color": "RoofColorGlass",
"seat_type": null,
"spoiler_type": "None",
"sun_roof_installed": null,
"supports_qr_pairing": false,
"third_row_seats": "None",
"timestamp": 1658390117642,
"trim_badging": "9",
"use_range_badging": true,
"utc_offset": 0,
"webcam_supported": false,
"wheel_type": "StilettoRefresh19"
},
"command_signing": "allowed"
}
"#;
let energy_site: Product = serde_json::from_str(json).unwrap();
if let Product::Vehicle(v) = energy_site {
assert_eq!(v.id.0, 1111193485934);
assert_eq!(v.user_id, 2222291283912);
assert_eq!(v.vehicle_id.0, 333331238921);
assert_eq!(v.vin, "T234567890123456789");
assert_eq!(v.display_name.unwrap(), "My Vehicle");
assert_eq!(v.option_codes.unwrap(), "ASDF,SDFG,DFGH");
assert_eq!(v.color, None);
assert_eq!(v.access_type, "OWNER");
assert_eq!(v.tokens, vec!["asdf1234"]);
assert_eq!(v.state, "online");
assert!(!v.in_service);
assert!(v.calendar_enabled);
assert_eq!(v.api_version, 42);
assert_eq!(v.backseat_token, None);
assert_eq!(v.backseat_token_updated_at, None);
assert_eq!(
v.vehicle_config.unwrap().aux_park_lamps,
Some("Eu".to_string())
);
} else {
panic!("Wrong EnergySite");
}
}
#[test]
fn calendar_history_values() {
let v = CalendarHistoryValues {
site_id: EnergySiteId(123),
period: HistoryPeriod::Month,
kind: HistoryKind::Energy,
start_date: None,
end_date: None,
};
let url = v.format("https://base.com/e/{}/history");
assert_eq!(
url,
"https://base.com/e/123/history?period=month&kind=energy"
);
}
#[test]
fn calendar_history_values_dates() {
let v = CalendarHistoryValues {
site_id: EnergySiteId(123),
period: HistoryPeriod::Month,
kind: HistoryKind::Energy,
start_date: Some(DateTime::parse_from_rfc3339("2020-01-01T00:00:00Z").unwrap()),
end_date: Some(DateTime::parse_from_rfc3339("2020-01-31T23:59:59Z").unwrap()),
};
let url = v.format("https://base.com/e/{}/history");
assert_eq!(
url,
"https://base.com/e/123/history?period=month&kind=energy&start_date=2020-01-01T00:00:00Z&end_date=2020-01-31T23:59:59Z"
);
}
#[test]
fn json_products_gak_2024_01_20() {
let s = include_str!("../testdata/products_gak_2024_01_20.json");
let request_data = RequestData::Get { url: "" };
OwnerApi::parse_json::<Vec<Product>>(&request_data, s.to_string(), PrintResponses::Pretty)
.unwrap();
}
#[test]
fn json_products_gak_2024_04_12() {
let s = include_str!("../testdata/products_gak_2024_04_12.json");
let request_data = RequestData::Get { url: "" };
OwnerApi::parse_json::<Vec<Product>>(&request_data, s.to_string(), PrintResponses::Pretty)
.unwrap();
}
}