use serde::{Deserialize, Serialize};
use crate::oicp_open_enum;
use crate::types::{
Accessibility, AccessibilityLocation, ActionType, Address, AuthenticationMode,
CalibrationLawDataAvailability, ChargingFacility, ChargingPoolId, DateTime, DynamicInfoAvailable,
EnergySource, EnvironmentalImpact, EvseId, Extensions, GeoCoordinates, InfoText, Number, Opening,
OpeningTimes, OperatorId, PaymentOption, Plug, Text, Validate, Validator, ValueAddedService,
ViolationCode, strict_builder, validate_fields,
};
oicp_open_enum! {
pub enum DeltaType {
Insert = "insert",
Update = "update",
Delete = "delete",
}
}
oicp_open_enum! {
pub enum EvseStatus {
Available = "Available",
Reserved = "Reserved",
Occupied = "Occupied",
OutOfService = "OutOfService",
EvseNotFound = "EvseNotFound",
Unknown = "Unknown",
}
}
impl EvseStatus {
#[must_use]
pub fn is_chargeable(&self) -> bool {
matches!(self, Self::Available)
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, bon::Builder)]
#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
#[builder(finish_fn = build_unchecked)]
pub struct EvseDataRecord {
#[serde(rename = "deltaType", default, skip_serializing_if = "Option::is_none")]
pub delta_type: Option<DeltaType>,
#[serde(rename = "lastUpdate", default, skip_serializing_if = "Option::is_none")]
pub last_update: Option<DateTime>,
#[serde(rename = "EvseID")]
pub evse_id: EvseId,
#[serde(rename = "ChargingPoolID", default, skip_serializing_if = "Option::is_none")]
pub charging_pool_id: Option<ChargingPoolId>,
#[serde(
rename = "ChargingStationId",
alias = "ChargingStationID",
default,
skip_serializing_if = "Option::is_none"
)]
#[builder(into)]
pub charging_station_id: Option<Text<50>>,
#[serde(rename = "ChargingStationNames")]
pub charging_station_names: Vec<InfoText>,
#[serde(rename = "HardwareManufacturer", default, skip_serializing_if = "Option::is_none")]
#[builder(into)]
pub hardware_manufacturer: Option<Text<50>>,
#[serde(rename = "ChargingStationImage", default, skip_serializing_if = "Option::is_none")]
#[builder(into)]
pub charging_station_image: Option<Text<200>>,
#[serde(rename = "SubOperatorName", default, skip_serializing_if = "Option::is_none")]
#[builder(into)]
pub sub_operator_name: Option<Text<100>>,
#[serde(rename = "Address")]
pub address: Address,
#[serde(rename = "GeoCoordinates")]
pub geo_coordinates: GeoCoordinates,
#[serde(rename = "Plugs")]
pub plugs: Vec<Plug>,
#[serde(rename = "DynamicPowerLevel", default, skip_serializing_if = "Option::is_none")]
pub dynamic_power_level: Option<bool>,
#[serde(rename = "ChargingFacilities")]
pub charging_facilities: Vec<ChargingFacility>,
#[serde(rename = "RenewableEnergy")]
pub renewable_energy: bool,
#[serde(rename = "EnergySource", default, skip_serializing_if = "Option::is_none")]
pub energy_source: Option<Vec<EnergySource>>,
#[serde(rename = "EnvironmentalImpact", default, skip_serializing_if = "Option::is_none")]
pub environmental_impact: Option<EnvironmentalImpact>,
#[serde(rename = "CalibrationLawDataAvailability")]
pub calibration_law_data_availability: CalibrationLawDataAvailability,
#[serde(rename = "AuthenticationModes")]
pub authentication_modes: Vec<AuthenticationMode>,
#[serde(rename = "MaxCapacity", default, skip_serializing_if = "Option::is_none")]
pub max_capacity: Option<Number>,
#[serde(rename = "PaymentOptions")]
pub payment_options: Vec<PaymentOption>,
#[serde(rename = "ValueAddedServices")]
pub value_added_services: Vec<ValueAddedService>,
#[serde(rename = "Accessibility")]
pub accessibility: Accessibility,
#[serde(rename = "AccessibilityLocation", default, skip_serializing_if = "Option::is_none")]
pub accessibility_location: Option<AccessibilityLocation>,
#[serde(rename = "HotlinePhoneNumber")]
#[builder(into)]
pub hotline_phone_number: Text<20>,
#[serde(rename = "AdditionalInfo", default, skip_serializing_if = "Option::is_none")]
pub additional_info: Option<Vec<InfoText>>,
#[serde(rename = "ChargingStationLocationReference", default, skip_serializing_if = "Option::is_none")]
pub charging_station_location_reference: Option<Vec<InfoText>>,
#[serde(rename = "GeoChargingPointEntrance", default, skip_serializing_if = "Option::is_none")]
pub geo_charging_point_entrance: Option<GeoCoordinates>,
#[serde(rename = "IsOpen24Hours")]
pub is_open_24_hours: bool,
#[serde(rename = "OpeningTimes", default, skip_serializing_if = "Option::is_none")]
pub opening_times: Option<Vec<OpeningTimes>>,
#[serde(rename = "HubOperatorID", default, skip_serializing_if = "Option::is_none")]
pub hub_operator_id: Option<OperatorId>,
#[serde(rename = "ClearinghouseID", default, skip_serializing_if = "Option::is_none")]
#[builder(into)]
pub clearinghouse_id: Option<Text<20>>,
#[serde(rename = "IsHubjectCompatible")]
pub is_hubject_compatible: bool,
#[serde(rename = "DynamicInfoAvailable")]
pub dynamic_info_available: DynamicInfoAvailable,
#[serde(flatten, default, skip_serializing_if = "Extensions::is_empty")]
#[builder(default)]
pub extensions: Extensions,
}
impl EvseDataRecord {
#[must_use]
pub fn is_open_at(&self, at: &DateTime) -> Opening {
crate::types::opening_at(
self.is_open_24_hours,
self.opening_times.as_ref(),
self.address.time_zone.as_deref(),
at,
)
}
}
#[allow(clippy::too_many_arguments)]
pub(crate) fn validate_evse_common(
v: &mut Validator,
plugs: &[Plug],
charging_facilities: &[ChargingFacility],
authentication_modes: &[AuthenticationMode],
payment_options: &[PaymentOption],
charging_station_names: &[InfoText],
hotline_phone_number: &Text<20>,
is_open_24_hours: bool,
opening_times: Option<&Vec<OpeningTimes>>,
) {
for (name, empty) in [
("Plugs", plugs.is_empty()),
("ChargingFacilities", charging_facilities.is_empty()),
("AuthenticationModes", authentication_modes.is_empty()),
("PaymentOptions", payment_options.is_empty()),
("ChargingStationNames", charging_station_names.is_empty()),
] {
if empty {
v.report_at(
name,
ViolationCode::EmptyRequiredList,
format!("{name} is mandatory and must not be empty"),
);
}
}
if payment_options.contains(&PaymentOption::NoPayment) && payment_options.len() > 1 {
v.report_at(
"PaymentOptions",
ViolationCode::Inconsistent,
"'No Payment' cannot be combined with another payment option",
);
}
let phone = hotline_phone_number.as_str();
let digits = phone.strip_prefix('+').unwrap_or("");
if !phone.starts_with('+')
|| !(5..=15).contains(&digits.len())
|| !digits.bytes().all(|c| c.is_ascii_digit())
{
v.report_at(
"HotlinePhoneNumber",
ViolationCode::PatternMismatch,
format!("{phone:?} is not a '+' followed by 5 to 15 digits"),
);
}
match (is_open_24_hours, opening_times) {
(false, None) => v.report_at(
"OpeningTimes",
ViolationCode::MissingConditional,
"IsOpen24Hours is false, so OpeningTimes is required — otherwise no driver can tell when \
the station can be used",
),
(false, Some(times)) if times.is_empty() => v.report_at(
"OpeningTimes",
ViolationCode::EmptyRequiredList,
"IsOpen24Hours is false, so OpeningTimes must list at least one period",
),
(true, Some(times)) if !times.is_empty() => v.report_at(
"OpeningTimes",
ViolationCode::Inconsistent,
"IsOpen24Hours is true, so OpeningTimes contradicts it",
),
_ => {}
}
}
impl Validate for EvseDataRecord {
fn validate_in(&self, v: &mut Validator) {
validate_evse_common(
v,
&self.plugs,
&self.charging_facilities,
&self.authentication_modes,
&self.payment_options,
&self.charging_station_names,
&self.hotline_phone_number,
self.is_open_24_hours,
self.opening_times.as_ref(),
);
validate_fields!(
self,
v,
evse_id as "EvseID",
charging_pool_id as "ChargingPoolID",
charging_station_id as "ChargingStationId",
charging_station_names as "ChargingStationNames",
hardware_manufacturer as "HardwareManufacturer",
charging_station_image as "ChargingStationImage",
sub_operator_name as "SubOperatorName",
address as "Address",
geo_coordinates as "GeoCoordinates",
plugs as "Plugs",
charging_facilities as "ChargingFacilities",
energy_source as "EnergySource",
environmental_impact as "EnvironmentalImpact",
calibration_law_data_availability as "CalibrationLawDataAvailability",
authentication_modes as "AuthenticationModes",
payment_options as "PaymentOptions",
value_added_services as "ValueAddedServices",
accessibility as "Accessibility",
accessibility_location as "AccessibilityLocation",
additional_info as "AdditionalInfo",
charging_station_location_reference as "ChargingStationLocationReference",
geo_charging_point_entrance as "GeoChargingPointEntrance",
opening_times as "OpeningTimes",
hub_operator_id as "HubOperatorID",
clearinghouse_id as "ClearinghouseID",
dynamic_info_available as "DynamicInfoAvailable",
last_update as "lastUpdate",
);
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, bon::Builder)]
#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
#[builder(finish_fn = build_unchecked)]
pub struct OperatorEvseData {
#[serde(rename = "OperatorID")]
pub operator_id: OperatorId,
#[serde(rename = "OperatorName")]
#[builder(into)]
pub operator_name: Text<100>,
#[serde(rename = "EvseDataRecord")]
pub evse_data_record: Vec<EvseDataRecord>,
#[serde(flatten, default, skip_serializing_if = "Extensions::is_empty")]
#[builder(default)]
pub extensions: Extensions,
}
impl Validate for OperatorEvseData {
fn validate_in(&self, v: &mut Validator) {
for (i, record) in self.evse_data_record.iter().enumerate() {
let derived = record.evse_id.operator_id();
if derived != self.operator_id {
v.enter("EvseDataRecord");
v.enter(&i.to_string());
v.report_at(
"EvseID",
ViolationCode::Inconsistent,
format!(
"{} belongs to operator {derived}, but this push is for {}; \
Hubject answers that with 018 Inconsistent EvseID",
record.evse_id, self.operator_id
),
);
v.leave();
v.leave();
}
}
validate_fields!(
self,
v,
operator_id as "OperatorID",
operator_name as "OperatorName",
evse_data_record as "EvseDataRecord",
);
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, bon::Builder)]
#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
#[builder(finish_fn = build_unchecked)]
pub struct PushEvseDataRequest {
#[serde(rename = "ActionType")]
pub action_type: ActionType,
#[serde(rename = "OperatorEvseData")]
pub operator_evse_data: OperatorEvseData,
}
impl Validate for PushEvseDataRequest {
fn validate_in(&self, v: &mut Validator) {
if self.action_type.is_destructive_replace() && self.operator_evse_data.evse_data_record.is_empty() {
v.report(
ViolationCode::Inconsistent,
"a fullLoad with no records removes every charging point this operator has from the \
roaming network; send an explicit delete if that is the intention",
);
}
validate_fields!(self, v, action_type as "ActionType", operator_evse_data as "OperatorEvseData");
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, bon::Builder)]
#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
#[builder(finish_fn = build_unchecked)]
pub struct EvseStatusRecord {
#[serde(rename = "EvseID")]
pub evse_id: EvseId,
#[serde(rename = "EvseStatus")]
pub evse_status: EvseStatus,
#[serde(flatten, default, skip_serializing_if = "Extensions::is_empty")]
#[builder(default)]
pub extensions: Extensions,
}
impl Validate for EvseStatusRecord {
fn validate_in(&self, v: &mut Validator) {
validate_fields!(self, v, evse_id as "EvseID", evse_status as "EvseStatus");
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, bon::Builder)]
#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
#[builder(finish_fn = build_unchecked)]
pub struct OperatorEvseStatus {
#[serde(rename = "OperatorID")]
pub operator_id: OperatorId,
#[serde(rename = "OperatorName", default, skip_serializing_if = "Option::is_none")]
#[builder(into)]
pub operator_name: Option<Text<100>>,
#[serde(rename = "EvseStatusRecord")]
pub evse_status_record: Vec<EvseStatusRecord>,
#[serde(flatten, default, skip_serializing_if = "Extensions::is_empty")]
#[builder(default)]
pub extensions: Extensions,
}
impl Validate for OperatorEvseStatus {
fn validate_in(&self, v: &mut Validator) {
validate_fields!(
self,
v,
operator_id as "OperatorID",
operator_name as "OperatorName",
evse_status_record as "EvseStatusRecord",
);
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, bon::Builder)]
#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
#[builder(finish_fn = build_unchecked)]
pub struct PushEvseStatusRequest {
#[serde(rename = "ActionType")]
pub action_type: ActionType,
#[serde(rename = "OperatorEvseStatus")]
pub operator_evse_status: OperatorEvseStatus,
}
impl Validate for PushEvseStatusRequest {
fn validate_in(&self, v: &mut Validator) {
if self.action_type.is_destructive_replace()
&& self.operator_evse_status.evse_status_record.is_empty()
{
v.report(
ViolationCode::Inconsistent,
"a fullLoad with no records withdraws the status of every charging point this \
operator has",
);
}
validate_fields!(self, v, action_type as "ActionType", operator_evse_status as "OperatorEvseStatus");
}
}
strict_builder!(EvseDataRecord, EvseDataRecordBuilder, evse_data_record_builder);
strict_builder!(OperatorEvseData, OperatorEvseDataBuilder, operator_evse_data_builder);
strict_builder!(PushEvseDataRequest, PushEvseDataRequestBuilder, push_evse_data_request_builder);
strict_builder!(EvseStatusRecord, EvseStatusRecordBuilder, evse_status_record_builder);
strict_builder!(OperatorEvseStatus, OperatorEvseStatusBuilder, operator_evse_status_builder);
strict_builder!(PushEvseStatusRequest, PushEvseStatusRequestBuilder, push_evse_status_request_builder);
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_status_record_keeps_fields_hubject_adds_later() {
let json = r#"{"EvseID":"DE*XYZ*ETEST1","EvseStatus":"Available","HubjectAddedThis":42}"#;
let record: EvseStatusRecord = serde_json::from_str(json).unwrap();
assert_eq!(record.extensions.get::<u32>("HubjectAddedThis").unwrap(), Some(42));
assert_eq!(serde_json::to_string(&record).unwrap(), json);
}
#[test]
fn a_status_value_hubject_adds_later_is_kept() {
let record: EvseStatusRecord =
serde_json::from_str(r#"{"EvseID":"DE*XYZ*ETEST1","EvseStatus":"Maintenance"}"#).unwrap();
assert!(!record.evse_status.is_known());
assert!(!record.evse_status.is_chargeable());
assert_eq!(record.evse_status.as_str(), "Maintenance");
}
#[test]
fn charging_station_id_decodes_under_both_spellings() {
#[derive(serde::Deserialize)]
struct Probe {
#[serde(rename = "ChargingStationId", alias = "ChargingStationID")]
id: String,
}
for key in ["ChargingStationId", "ChargingStationID"] {
let json = format!(r#"{{"{key}":"TEST 1"}}"#);
let probe: Probe = serde_json::from_str(&json).unwrap();
assert_eq!(probe.id, "TEST 1");
}
}
#[test]
fn a_full_load_with_no_records_is_reported() {
let push = PushEvseDataRequest {
action_type: ActionType::FullLoad,
operator_evse_data: OperatorEvseData {
operator_id: "DE*ABC".parse().unwrap(),
operator_name: Text::new("ABC technologies").unwrap(),
evse_data_record: vec![],
extensions: Extensions::new(),
},
};
let err = push.validate().unwrap_err();
assert!(err.as_slice()[0].message.contains("removes every charging point"));
let push = PushEvseDataRequest { action_type: ActionType::Delete, ..push };
assert!(push.validate().is_ok());
}
#[test]
fn a_record_whose_operator_does_not_match_the_push_is_reported() {
let data = OperatorEvseData {
operator_id: "DE*ABC".parse().unwrap(),
operator_name: Text::new("ABC technologies").unwrap(),
evse_data_record: vec![],
extensions: Extensions::new(),
};
assert!(data.validate().is_ok());
}
}