use alloc::string::String;
use alloc::vec::Vec;
use crate::metering::SignedMeterValue;
use crate::types::{DateTime, Decimal};
use crate::version::Version;
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub enum DomainEvent {
Booted {
vendor: String,
model: String,
serial_number: Option<String>,
firmware_version: Option<String>,
reason: Option<String>,
},
Heartbeat,
StatusChanged {
evse_id: Option<i32>,
connector_id: Option<i32>,
status: String,
error_code: Option<String>,
timestamp: Option<DateTime>,
},
AuthorizeRequested {
id_token: String,
id_token_type: Option<String>,
},
TransactionStarted {
transaction_id: Option<String>,
evse_id: Option<i32>,
connector_id: Option<i32>,
seq_no: Option<i32>,
id_token: Option<String>,
meter_start: Option<EnergyReading>,
signed: Vec<SignedReading>,
timestamp: DateTime,
},
TransactionUpdated {
transaction_id: String,
evse_id: Option<i32>,
connector_id: Option<i32>,
charging_state: Option<String>,
seq_no: Option<i32>,
meter: Option<EnergyReading>,
signed: Vec<SignedReading>,
offline: bool,
timestamp: DateTime,
},
TransactionEnded {
transaction_id: String,
evse_id: Option<i32>,
connector_id: Option<i32>,
charging_state: Option<String>,
seq_no: Option<i32>,
stopped_reason: Option<String>,
meter_stop: Option<EnergyReading>,
signed: Vec<SignedReading>,
timestamp: DateTime,
},
MeterValues {
evse_id: Option<i32>,
connector_id: Option<i32>,
transaction_id: Option<String>,
samples: usize,
energy: Option<EnergyReading>,
signed: Vec<SignedReading>,
timestamp: Option<DateTime>,
},
SecurityEvent {
event_type: String,
timestamp: DateTime,
info: Option<String>,
},
FirmwareStatus {
status: String,
},
Other {
action: String,
},
}
#[derive(Clone, Debug, PartialEq)]
pub struct Observed {
pub event: DomainEvent,
pub version: Version,
pub warnings: Vec<Warning>,
}
impl Observed {
#[cfg(any(feature = "v1_6", feature = "v2_0_1", feature = "v2_1"))]
fn new(version: Version, event: DomainEvent, warnings: Vec<Warning>) -> Self {
Self {
event,
version,
warnings,
}
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Warning {
pub kind: WarningKind,
pub detail: String,
}
impl Warning {
#[cfg(any(feature = "v1_6", feature = "v2_0_1", feature = "v2_1"))]
fn new(kind: WarningKind, detail: impl Into<String>) -> Self {
Self {
kind,
detail: detail.into(),
}
}
}
impl core::fmt::Display for Warning {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(f, "{}: {}", self.kind.as_str(), self.detail)
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[non_exhaustive]
pub enum WarningKind {
UnreadableSignedData,
UnreadableReading,
UnknownEnergyUnit,
UnrepresentableReading,
}
impl WarningKind {
#[must_use]
pub const fn as_str(self) -> &'static str {
match self {
WarningKind::UnreadableSignedData => "unreadable signed data",
WarningKind::UnreadableReading => "unreadable reading",
WarningKind::UnknownEnergyUnit => "unknown energy unit",
WarningKind::UnrepresentableReading => "unrepresentable reading",
}
}
}
impl core::fmt::Display for WarningKind {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.write_str(self.as_str())
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub struct EnergyReading {
pub wh: Decimal,
pub context: Option<String>,
pub signed: Option<SignedMeterValue>,
}
#[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct SignedReading {
pub value: SignedMeterValue,
pub context: Option<String>,
pub measurand: Option<String>,
}
#[cfg(any(feature = "v1_6", feature = "v2_0_1", feature = "v2_1"))]
struct Sample<'a> {
measurand: Option<&'a str>,
unit: Option<&'a str>,
multiplier: Option<i32>,
context: Option<&'a str>,
value: Option<Decimal>,
unreadable_value: Option<&'a str>,
signed: Option<Result<SignedMeterValue, crate::metering::SignedDataError>>,
}
#[cfg(any(feature = "v1_6", feature = "v2_0_1", feature = "v2_1"))]
#[derive(Clone, Copy, PartialEq, Eq)]
#[cfg_attr(
not(any(feature = "v2_0_1", feature = "v2_1")),
allow(dead_code, clippy::allow_attributes)
)]
enum Prefer {
First,
Last,
}
#[cfg(any(feature = "v1_6", feature = "v2_0_1", feature = "v2_1"))]
const ENERGY_REGISTER: &str = "Energy.Active.Import.Register";
#[cfg(any(feature = "v1_6", feature = "v2_0_1", feature = "v2_1"))]
fn signed_from_samples<'a>(
samples: impl Iterator<Item = Sample<'a>>,
warnings: &mut Vec<Warning>,
) -> Vec<SignedReading> {
let mut out = Vec::new();
for sample in samples {
match sample.signed {
Some(Ok(value)) => out.push(SignedReading {
value,
context: sample.context.map(alloc::string::ToString::to_string),
measurand: sample.measurand.map(alloc::string::ToString::to_string),
}),
Some(Err(error)) => warnings.push(Warning::new(
WarningKind::UnreadableSignedData,
error.reason(),
)),
None => {}
}
}
out
}
#[cfg(any(feature = "v1_6", feature = "v2_0_1", feature = "v2_1"))]
fn energy_from_samples<'a>(
samples: impl Iterator<Item = Sample<'a>>,
prefer: Prefer,
preferred_context: Option<&str>,
warnings: &mut Vec<Warning>,
) -> Option<EnergyReading> {
let mut best: Option<EnergyReading> = None;
let mut best_in_context: Option<EnergyReading> = None;
for sample in samples {
if sample.measurand.unwrap_or(ENERGY_REGISTER) != ENERGY_REGISTER {
continue;
}
let Some(value) = sample.value else {
if let Some(text) = sample.unreadable_value {
warnings.push(Warning::new(WarningKind::UnreadableReading, text));
}
continue;
};
let Some(exponent) = unit_exponent(sample.unit) else {
warnings.push(Warning::new(
WarningKind::UnknownEnergyUnit,
sample.unit.unwrap_or_default(),
));
continue;
};
let converted = value
.checked_pow10(sample.multiplier.unwrap_or(0))
.and_then(|scaled| scaled.checked_pow10(exponent));
let Some(wh) = converted else {
warnings.push(Warning::new(
WarningKind::UnrepresentableReading,
alloc::format!("{value} with multiplier {}", sample.multiplier.unwrap_or(0)),
));
continue;
};
let reading = EnergyReading {
wh,
context: sample.context.map(alloc::string::ToString::to_string),
signed: sample.signed.and_then(Result::ok),
};
let in_context = preferred_context.is_some_and(|wanted| sample.context == Some(wanted));
for slot in [Some(&mut best), in_context.then_some(&mut best_in_context)]
.into_iter()
.flatten()
{
if slot.is_none() || prefer == Prefer::Last {
*slot = Some(reading.clone());
}
}
}
best_in_context.or(best)
}
#[cfg(any(feature = "v1_6", feature = "v2_0_1", feature = "v2_1"))]
fn unit_exponent(unit: Option<&str>) -> Option<i32> {
match unit {
None => Some(0),
Some(unit) if unit.eq_ignore_ascii_case("wh") => Some(0),
Some(unit) if unit.eq_ignore_ascii_case("kwh") => Some(3),
Some(unit) if unit.eq_ignore_ascii_case("mwh") => Some(6),
Some(_) => None,
}
}
#[cfg(feature = "v1_6")]
mod v16_conversion {
use super::{
DomainEvent, EnergyReading, Observed, Prefer, Sample, energy_from_samples,
signed_from_samples,
};
use crate::types::Decimal;
use crate::v1_6;
use crate::version::Version;
use alloc::string::ToString;
use alloc::vec::Vec;
fn transaction_data(stop: &v1_6::StopTransactionRequest) -> &[v1_6::MeterValue] {
stop.transaction_data.as_deref().unwrap_or_default()
}
fn samples(values: &[v1_6::MeterValue]) -> impl Iterator<Item = Sample<'_>> {
values.iter().flat_map(|entry| {
entry.sampled_value.iter().map(|sample| {
let signed = sample.signed_meter_value();
let measurement = signed.is_none().then(|| sample.value.parse::<Decimal>());
Sample {
measurand: sample.measurand.as_ref().map(v1_6::Measurand::as_str),
unit: sample.unit.as_ref().map(v1_6::UnitOfMeasure::as_str),
multiplier: None,
context: sample.context.as_ref().map(v1_6::ReadingContext::as_str),
value: measurement.and_then(Result::ok),
unreadable_value: matches!(measurement, Some(Err(_)))
.then_some(sample.value.as_str()),
signed,
}
})
})
}
#[must_use]
pub fn observe(request: &v1_6::CsRequest) -> Observed {
let mut warnings = Vec::new();
let event = match request {
v1_6::CsRequest::BootNotification(boot) => DomainEvent::Booted {
vendor: boot.charge_point_vendor.clone(),
model: boot.charge_point_model.clone(),
serial_number: boot
.charge_point_serial_number
.clone()
.or_else(|| boot.charge_box_serial_number.clone()),
firmware_version: boot.firmware_version.clone(),
reason: None,
},
v1_6::CsRequest::Heartbeat(_) => DomainEvent::Heartbeat,
v1_6::CsRequest::StatusNotification(status) => DomainEvent::StatusChanged {
evse_id: None,
connector_id: Some(status.connector_id),
status: status.status.as_str().to_string(),
error_code: Some(status.error_code.as_str().to_string()),
timestamp: status.timestamp,
},
v1_6::CsRequest::Authorize(authorize) => DomainEvent::AuthorizeRequested {
id_token: authorize.id_tag.clone(),
id_token_type: None,
},
v1_6::CsRequest::StartTransaction(start) => DomainEvent::TransactionStarted {
transaction_id: None,
evse_id: None,
connector_id: Some(start.connector_id),
seq_no: None,
id_token: Some(start.id_tag.clone()),
meter_start: Some(EnergyReading {
wh: Decimal::from(start.meter_start),
context: Some(v1_6::ReadingContext::TransactionBegin.as_str().to_string()),
signed: None,
}),
signed: Vec::new(),
timestamp: start.timestamp,
},
v1_6::CsRequest::StopTransaction(stop) => DomainEvent::TransactionEnded {
transaction_id: stop.transaction_id.to_string(),
evse_id: None,
connector_id: None,
charging_state: None,
seq_no: None,
stopped_reason: stop
.reason
.as_ref()
.map(|reason| reason.as_str().to_string()),
meter_stop: Some(EnergyReading {
wh: Decimal::from(stop.meter_stop),
context: Some(v1_6::ReadingContext::TransactionEnd.as_str().to_string()),
signed: None,
}),
signed: signed_from_samples(samples(transaction_data(stop)), &mut warnings),
timestamp: stop.timestamp,
},
v1_6::CsRequest::MeterValues(values) => {
let count: usize = values
.meter_value
.iter()
.map(|entry| entry.sampled_value.len())
.sum();
DomainEvent::MeterValues {
evse_id: None,
connector_id: Some(values.connector_id),
transaction_id: values.transaction_id.map(|id| id.to_string()),
samples: count,
energy: energy_from_samples(
samples(&values.meter_value),
Prefer::Last,
None,
&mut warnings,
),
signed: signed_from_samples(samples(&values.meter_value), &mut warnings),
timestamp: values.meter_value.iter().map(|entry| entry.timestamp).max(),
}
}
v1_6::CsRequest::SecurityEventNotification(security) => DomainEvent::SecurityEvent {
event_type: security.r#type.clone(),
timestamp: security.timestamp,
info: security.tech_info.clone(),
},
v1_6::CsRequest::FirmwareStatusNotification(status) => DomainEvent::FirmwareStatus {
status: status.status.as_str().to_string(),
},
other => DomainEvent::Other {
action: other.action().as_str().to_string(),
},
};
Observed::new(Version::V1_6, event, warnings)
}
}
#[cfg(feature = "v1_6")]
pub use v16_conversion::observe as observe_v16;
#[cfg(any(feature = "v2_0_1", feature = "v2_1"))]
macro_rules! observe_2x {
($module:ident, $version:expr, $wrapper:ident, $name:ident) => {
mod $wrapper {
use super::{
DomainEvent, Observed, Prefer, Sample, Warning, energy_from_samples,
signed_from_samples,
};
use crate::version::Version;
use alloc::vec::Vec;
fn samples(values: &[crate::$module::MeterValue]) -> impl Iterator<Item = Sample<'_>> {
use crate::$module as v;
values.iter().flat_map(|entry| {
entry.sampled_value.iter().map(|sample| Sample {
measurand: sample.measurand.as_ref().map(v::Measurand::as_str),
unit: sample
.unit_of_measure
.as_ref()
.and_then(|unit| unit.unit.as_deref()),
multiplier: sample
.unit_of_measure
.as_ref()
.and_then(|unit| unit.multiplier),
context: sample.context.as_ref().map(v::ReadingContext::as_str),
value: Some(sample.value),
unreadable_value: None,
signed: sample
.signed_meter_value
.as_ref()
.map(|value| Ok(value.into())),
})
})
}
#[must_use]
#[allow(clippy::too_many_lines)]
pub fn observe(request: &crate::$module::CsRequest) -> Observed {
use crate::$module as v;
use alloc::string::ToString as _;
let mut warnings = Vec::new();
let event = match request {
v::CsRequest::BootNotification(boot) => DomainEvent::Booted {
vendor: boot.charging_station.vendor_name.clone(),
model: boot.charging_station.model.clone(),
serial_number: boot.charging_station.serial_number.clone(),
firmware_version: boot.charging_station.firmware_version.clone(),
reason: Some(boot.reason.as_str().to_string()),
},
v::CsRequest::Heartbeat(_) => DomainEvent::Heartbeat,
v::CsRequest::StatusNotification(status) => DomainEvent::StatusChanged {
evse_id: Some(status.evse_id),
connector_id: Some(status.connector_id),
status: status.connector_status.as_str().to_string(),
error_code: None,
timestamp: Some(status.timestamp),
},
v::CsRequest::Authorize(authorize) => DomainEvent::AuthorizeRequested {
id_token: authorize.id_token.id_token.clone(),
id_token_type: Some(authorize.id_token.r#type.as_str().to_string()),
},
v::CsRequest::TransactionEvent(event) => {
let entries: &[v::MeterValue] =
event.meter_value.as_deref().unwrap_or_default();
let evse_id = event.evse.as_ref().map(|evse| evse.id);
let connector_id = event.evse.as_ref().and_then(|evse| evse.connector_id);
let charging_state = event
.transaction_info
.charging_state
.as_ref()
.map(|state| state.as_str().to_string());
let energy = |prefer, context, warnings: &mut Vec<Warning>| {
energy_from_samples(samples(entries), prefer, Some(context), warnings)
};
match event.event_type {
v::TransactionEventEnum::Started => DomainEvent::TransactionStarted {
transaction_id: Some(event.transaction_info.transaction_id.clone()),
evse_id,
connector_id,
seq_no: Some(event.seq_no),
id_token: event
.id_token
.as_ref()
.map(|token| token.id_token.clone()),
meter_start: energy(
Prefer::First,
v::ReadingContext::TransactionBegin.as_str(),
&mut warnings,
),
signed: signed_from_samples(samples(entries), &mut warnings),
timestamp: event.timestamp,
},
v::TransactionEventEnum::Ended => DomainEvent::TransactionEnded {
transaction_id: event.transaction_info.transaction_id.clone(),
evse_id,
connector_id,
charging_state,
seq_no: Some(event.seq_no),
stopped_reason: event
.transaction_info
.stopped_reason
.as_ref()
.map(|reason| reason.as_str().to_string()),
meter_stop: energy(
Prefer::Last,
v::ReadingContext::TransactionEnd.as_str(),
&mut warnings,
),
signed: signed_from_samples(samples(entries), &mut warnings),
timestamp: event.timestamp,
},
_ => DomainEvent::TransactionUpdated {
transaction_id: event.transaction_info.transaction_id.clone(),
evse_id,
connector_id,
charging_state,
seq_no: Some(event.seq_no),
meter: energy_from_samples(
samples(entries),
Prefer::Last,
None,
&mut warnings,
),
signed: signed_from_samples(samples(entries), &mut warnings),
offline: event.offline.unwrap_or(false),
timestamp: event.timestamp,
},
}
}
v::CsRequest::MeterValues(values) => {
let count: usize = values
.meter_value
.iter()
.map(|entry| entry.sampled_value.len())
.sum();
DomainEvent::MeterValues {
evse_id: Some(values.evse_id),
connector_id: None,
transaction_id: None,
samples: count,
energy: energy_from_samples(
samples(&values.meter_value),
Prefer::Last,
None,
&mut warnings,
),
signed: signed_from_samples(
samples(&values.meter_value),
&mut warnings,
),
timestamp: values.meter_value.iter().map(|entry| entry.timestamp).max(),
}
}
v::CsRequest::SecurityEventNotification(security) => {
DomainEvent::SecurityEvent {
event_type: security.r#type.clone(),
timestamp: security.timestamp,
info: security.tech_info.clone(),
}
}
v::CsRequest::FirmwareStatusNotification(status) => {
DomainEvent::FirmwareStatus {
status: status.status.as_str().to_string(),
}
}
other => DomainEvent::Other {
action: other.action().as_str().to_string(),
},
};
Observed::new($version, event, warnings)
}
}
pub use $wrapper::observe as $name;
};
}
#[cfg(feature = "v2_0_1")]
observe_2x!(v2_0_1, Version::V2_0_1, v201_conversion, observe_v201);
#[cfg(feature = "v2_1")]
observe_2x!(v2_1, Version::V2_1, v21_conversion, observe_v21);
#[must_use]
pub fn to_ledger_event(
identity: &crate::types::Identity,
observed: &Observed,
) -> Option<super::ledger::TransactionEvent> {
to_ledger_event_inner(identity, observed, None)
}
#[must_use]
pub fn to_ledger_event_with_id(
identity: &crate::types::Identity,
observed: &Observed,
transaction_id: &str,
) -> Option<super::ledger::TransactionEvent> {
to_ledger_event_inner(identity, observed, Some(transaction_id))
}
struct LedgerParts<'a> {
transaction_id: String,
evse_id: Option<i32>,
connector_id: Option<i32>,
seq_no: Option<i32>,
kind: super::ledger::EventKind,
timestamp: DateTime,
reading: &'a Option<EnergyReading>,
signed: &'a [SignedReading],
}
#[allow(clippy::too_many_lines)]
fn ledger_parts<'a>(event: &'a DomainEvent, assigned: Option<&str>) -> Option<LedgerParts<'a>> {
use super::ledger::EventKind;
let parts = match event {
DomainEvent::TransactionStarted {
transaction_id,
evse_id,
connector_id,
seq_no,
meter_start,
signed,
timestamp,
..
} => LedgerParts {
transaction_id: transaction_id
.clone()
.or_else(|| assigned.map(alloc::string::ToString::to_string))?,
evse_id: *evse_id,
connector_id: *connector_id,
seq_no: *seq_no,
kind: EventKind::Started,
timestamp: *timestamp,
reading: meter_start,
signed,
},
DomainEvent::TransactionUpdated {
transaction_id,
evse_id,
connector_id,
seq_no,
meter,
signed,
timestamp,
..
} => LedgerParts {
transaction_id: transaction_id.clone(),
evse_id: *evse_id,
connector_id: *connector_id,
seq_no: *seq_no,
kind: EventKind::Updated,
timestamp: *timestamp,
reading: meter,
signed,
},
DomainEvent::TransactionEnded {
transaction_id,
evse_id,
connector_id,
seq_no,
meter_stop,
signed,
timestamp,
..
} => LedgerParts {
transaction_id: transaction_id.clone(),
evse_id: *evse_id,
connector_id: *connector_id,
seq_no: *seq_no,
kind: EventKind::Ended,
timestamp: *timestamp,
reading: meter_stop,
signed,
},
DomainEvent::MeterValues {
transaction_id: Some(transaction_id),
evse_id,
connector_id,
energy,
signed,
timestamp: Some(timestamp),
..
} => LedgerParts {
transaction_id: transaction_id.clone(),
evse_id: *evse_id,
connector_id: *connector_id,
seq_no: None,
kind: EventKind::Updated,
timestamp: *timestamp,
reading: energy,
signed,
},
_ => return None,
};
Some(parts)
}
fn to_ledger_event_inner(
identity: &crate::types::Identity,
observed: &Observed,
assigned: Option<&str>,
) -> Option<super::ledger::TransactionEvent> {
use super::ledger::TransactionEvent;
let parts = ledger_parts(&observed.event, assigned)?;
let mut event = TransactionEvent::new(
identity.clone(),
parts.transaction_id,
parts.seq_no.unwrap_or(0),
parts.kind,
parts.timestamp,
);
event.evse_id = parts.evse_id;
event.connector_id = parts.connector_id;
event.signed.extend_from_slice(parts.signed);
if let Some(reading) = parts.reading {
event.meter_wh = Some(reading.wh);
}
match &observed.event {
DomainEvent::TransactionStarted { id_token, .. } => event.id_token.clone_from(id_token),
DomainEvent::TransactionUpdated { offline, .. } => event.offline = *offline,
DomainEvent::TransactionEnded { stopped_reason, .. } => {
event.stopped_reason.clone_from(stopped_reason);
}
_ => {}
}
Some(event)
}
pub const COVERED_ACTIONS: &[&str] = &[
"Authorize",
"BootNotification",
"FirmwareStatusNotification",
"Heartbeat",
"MeterValues",
"SecurityEventNotification",
"StartTransaction",
"StatusNotification",
"StopTransaction",
"TransactionEvent",
];
#[cfg(all(test, feature = "v1_6", feature = "v2_1"))]
mod tests {
use super::*;
use crate::{v1_6, v2_1};
#[test]
fn a_boot_looks_the_same_in_16_and_21() {
let legacy = observe_v16(&v1_6::CsRequest::BootNotification(
v1_6::BootNotificationRequest::new("ACME", "Model-1").with_firmware_version("1.2.3"),
));
let modern = observe_v21(&v2_1::CsRequest::BootNotification(
v2_1::BootNotificationRequest::new(
v2_1::ChargingStation::new("Model-1", "ACME").with_firmware_version("1.2.3"),
v2_1::BootReason::PowerUp,
),
));
let DomainEvent::Booted {
vendor,
model,
firmware_version,
..
} = &legacy.event
else {
panic!("{:?}", legacy.event)
};
assert_eq!(vendor, "ACME");
assert_eq!(model, "Model-1");
assert_eq!(firmware_version.as_deref(), Some("1.2.3"));
let DomainEvent::Booted {
vendor,
model,
reason,
..
} = &modern.event
else {
panic!("{:?}", modern.event)
};
assert_eq!(vendor, "ACME");
assert_eq!(model, "Model-1");
assert_eq!(reason.as_deref(), Some("PowerUp"));
assert_eq!(legacy.version, Version::V1_6);
assert_eq!(modern.version, Version::V2_1);
}
#[test]
fn kwh_and_the_multiplier_are_both_applied_and_neither_rounds() {
let sample = |value: crate::types::Decimal, unit: v2_1::UnitOfMeasure| {
let request = v2_1::MeterValuesRequest::new(
1,
alloc::vec![v2_1::MeterValue::new(
alloc::vec![
v2_1::SampledValue::new(value)
.with_measurand(v2_1::Measurand::EnergyActiveImportRegister)
.with_unit_of_measure(unit)
],
DateTime::parse("2024-01-01T00:00:00Z").unwrap(),
)],
);
let observed = observe_v21(&v2_1::CsRequest::MeterValues(request));
let DomainEvent::MeterValues { energy, .. } = observed.event else {
panic!("expected MeterValues")
};
energy
};
let kwh = v2_1::UnitOfMeasure::new().with_unit("kWh");
let reading = sample(crate::decimal!(2935.600), kwh.clone()).expect("a reading");
assert_eq!(reading.wh.to_string(), "2935600");
let scaled = sample(
crate::decimal!(1.5),
v2_1::UnitOfMeasure::new()
.with_unit("kWh")
.with_multiplier(3),
)
.expect("a reading");
assert_eq!(scaled.wh.to_string(), "1500000");
assert!(
sample(
crate::decimal!(1),
v2_1::UnitOfMeasure::new().with_unit("A")
)
.is_none()
);
let mixed = v2_1::MeterValuesRequest::new(
1,
alloc::vec![v2_1::MeterValue::new(
alloc::vec![
v2_1::SampledValue::new(crate::decimal!(1))
.with_measurand(v2_1::Measurand::EnergyActiveImportRegister)
.with_unit_of_measure(v2_1::UnitOfMeasure::new().with_unit("A")),
v2_1::SampledValue::new(crate::decimal!(4500.5))
.with_measurand(v2_1::Measurand::EnergyActiveImportRegister),
],
DateTime::parse("2024-01-01T00:00:00Z").unwrap(),
)],
);
let observed = observe_v21(&v2_1::CsRequest::MeterValues(mixed));
let DomainEvent::MeterValues { energy, .. } = observed.event else {
panic!("expected MeterValues")
};
assert_eq!(energy.unwrap().wh.to_string(), "4500.5");
}
#[test]
fn the_closing_reading_wins_on_an_ended_event() {
let reading = |value, context| {
v2_1::SampledValue::new(value)
.with_measurand(v2_1::Measurand::EnergyActiveImportRegister)
.with_context(context)
};
let request = v2_1::TransactionEventRequest::new(
v2_1::TransactionEventEnum::Ended,
DateTime::parse("2024-01-01T01:00:00Z").unwrap(),
v2_1::TriggerReason::StopAuthorized,
2,
v2_1::Transaction::new("tx-1"),
)
.with_meter_value(alloc::vec![v2_1::MeterValue::new(
alloc::vec![
reading(crate::decimal!(4100), v2_1::ReadingContext::SamplePeriodic),
reading(
crate::decimal!(7300.250),
v2_1::ReadingContext::TransactionEnd
),
],
DateTime::parse("2024-01-01T01:00:00Z").unwrap(),
)]);
let observed = observe_v21(&v2_1::CsRequest::TransactionEvent(request));
let DomainEvent::TransactionEnded { meter_stop, .. } = &observed.event else {
panic!("{:?}", observed.event)
};
let reading = meter_stop.as_ref().expect("a closing reading");
assert_eq!(reading.wh.to_string(), "7300.250");
assert_eq!(reading.context.as_deref(), Some("Transaction.End"));
}
#[test]
fn an_unparseable_16_reading_is_skipped_rather_than_becoming_a_nan() {
let values = alloc::vec![v1_6::MeterValue::new(
DateTime::parse("2024-01-01T00:00:00Z").unwrap(),
alloc::vec![
v1_6::SampledValue::new("not a number")
.with_measurand(v1_6::Measurand::EnergyActiveImportRegister),
v1_6::SampledValue::new("4500.5")
.with_measurand(v1_6::Measurand::EnergyActiveImportRegister),
],
)];
let observed = observe_v16(&v1_6::CsRequest::MeterValues(
v1_6::MeterValuesRequest::new(1, values),
));
let DomainEvent::MeterValues {
energy, samples, ..
} = &observed.event
else {
panic!("{:?}", observed.event)
};
assert_eq!(*samples, 2);
assert_eq!(energy.as_ref().unwrap().wh.to_string(), "4500.5");
}
#[test]
fn a_16_start_reaches_the_ledger_once_the_csms_has_assigned_an_id() {
let identity = crate::types::Identity::new("CS-0001").unwrap();
let start = v1_6::StartTransactionRequest::new(
1,
"CARD-1",
2_935_600,
DateTime::parse("2024-01-01T00:00:00Z").unwrap(),
);
let observed = observe_v16(&v1_6::CsRequest::StartTransaction(start));
assert!(to_ledger_event(&identity, &observed).is_none());
let event = to_ledger_event_with_id(&identity, &observed, "42").expect("a start event");
let mut ledger = super::super::ledger::Ledger::new();
let _ = ledger.ingest_unsequenced(&event);
let stop = v1_6::StopTransactionRequest::new(
2_952_100,
DateTime::parse("2024-01-01T01:00:00Z").unwrap(),
42,
);
let observed = observe_v16(&v1_6::CsRequest::StopTransaction(stop));
let _ = ledger
.ingest_unsequenced(&to_ledger_event(&identity, &observed).expect("a stop event"));
let record = ledger.transaction(&identity, "42").unwrap();
assert_eq!(
record.energy().unwrap().unverified_wh().to_string(),
"16500"
);
}
#[test]
fn a_16_meter_values_message_naming_a_transaction_folds_into_the_ledger() {
let identity = crate::types::Identity::new("CS-0001").unwrap();
let mut ledger = super::super::ledger::Ledger::new();
let start = observe_v16(&v1_6::CsRequest::StartTransaction(
v1_6::StartTransactionRequest::new(
1,
"CARD-1",
1_000,
DateTime::parse("2024-01-01T00:00:00Z").unwrap(),
),
));
let _ =
ledger.ingest_unsequenced(&to_ledger_event_with_id(&identity, &start, "42").unwrap());
let periodic = observe_v16(&v1_6::CsRequest::MeterValues(
v1_6::MeterValuesRequest::new(
1,
alloc::vec![v1_6::MeterValue::new(
DateTime::parse("2024-01-01T00:30:00Z").unwrap(),
alloc::vec![
v1_6::SampledValue::new("4500.5")
.with_measurand(v1_6::Measurand::EnergyActiveImportRegister),
],
)],
)
.with_transaction_id(42),
));
let event = to_ledger_event(&identity, &periodic).expect("a mid-transaction reading");
assert_eq!(event.kind, super::super::ledger::EventKind::Updated);
let _ = ledger.ingest_unsequenced(&event);
let record = ledger.transaction(&identity, "42").unwrap();
assert_eq!(record.events(), 2);
assert!(record.is_open());
assert_eq!(record.meter_stop_wh.unwrap().to_string(), "4500.5");
assert_eq!(
record.energy().unwrap().unverified_wh().to_string(),
"3500.5"
);
let orphan = observe_v21(&v2_1::CsRequest::MeterValues(
v2_1::MeterValuesRequest::new(
1,
alloc::vec![v2_1::MeterValue::new(
alloc::vec![v2_1::SampledValue::new(crate::decimal!(1))],
DateTime::parse("2024-01-01T00:30:00Z").unwrap(),
)],
),
));
assert!(to_ledger_event(&identity, &orphan).is_none());
}
#[test]
fn a_station_that_claims_to_sign_and_does_not_is_reported() {
let values = alloc::vec![v1_6::MeterValue::new(
DateTime::parse("2024-01-01T00:00:00Z").unwrap(),
alloc::vec![
v1_6::SampledValue::new("this is not a JSON document")
.with_format(v1_6::ValueFormat::SignedData)
.with_measurand(v1_6::Measurand::EnergyActiveImportRegister),
v1_6::SampledValue::new("4500.5")
.with_measurand(v1_6::Measurand::EnergyActiveImportRegister),
],
)];
let observed = observe_v16(&v1_6::CsRequest::MeterValues(
v1_6::MeterValuesRequest::new(1, values),
));
let DomainEvent::MeterValues { energy, signed, .. } = &observed.event else {
panic!("{:?}", observed.event)
};
assert_eq!(energy.as_ref().unwrap().wh.to_string(), "4500.5");
assert!(signed.is_empty(), "{signed:?}");
assert_eq!(observed.warnings.len(), 1);
assert_eq!(observed.warnings[0].kind, WarningKind::UnreadableSignedData);
assert!(
observed.warnings[0]
.to_string()
.starts_with("unreadable signed data:")
);
}
#[test]
fn a_malformed_reading_and_an_impossible_unit_are_both_reported() {
let values = alloc::vec![v1_6::MeterValue::new(
DateTime::parse("2024-01-01T00:00:00Z").unwrap(),
alloc::vec![
v1_6::SampledValue::new("twelve")
.with_measurand(v1_6::Measurand::EnergyActiveImportRegister),
v1_6::SampledValue::new("7")
.with_measurand(v1_6::Measurand::EnergyActiveImportRegister)
.with_unit(v1_6::UnitOfMeasure::A),
v1_6::SampledValue::new("nonsense").with_measurand(v1_6::Measurand::Voltage),
],
)];
let observed = observe_v16(&v1_6::CsRequest::MeterValues(
v1_6::MeterValuesRequest::new(1, values),
));
let DomainEvent::MeterValues { energy, .. } = &observed.event else {
panic!("{:?}", observed.event)
};
assert!(energy.is_none(), "neither sample yields a register");
let kinds: Vec<WarningKind> = observed.warnings.iter().map(|w| w.kind).collect();
assert_eq!(
kinds,
alloc::vec![
WarningKind::UnreadableReading,
WarningKind::UnknownEnergyUnit
]
);
assert_eq!(observed.warnings[0].detail, "twelve");
assert_eq!(observed.warnings[1].detail, "A");
}
#[test]
fn a_well_formed_message_warns_about_nothing() {
let observed = observe_v21(&v2_1::CsRequest::Heartbeat(v2_1::HeartbeatRequest::new()));
assert!(observed.warnings.is_empty(), "{:?}", observed.warnings);
}
#[test]
fn the_charging_state_and_the_evse_survive_the_funnel() {
let request = v2_1::TransactionEventRequest::new(
v2_1::TransactionEventEnum::Updated,
DateTime::parse("2024-01-01T00:30:00Z").unwrap(),
v2_1::TriggerReason::MeterValuePeriodic,
3,
v2_1::Transaction::new("tx-1").with_charging_state(v2_1::ChargingState::SuspendedEV),
)
.with_evse(v2_1::EVSE::new(2).with_connector_id(1));
let observed = observe_v21(&v2_1::CsRequest::TransactionEvent(request));
let DomainEvent::TransactionUpdated {
charging_state,
evse_id,
connector_id,
..
} = &observed.event
else {
panic!("{:?}", observed.event)
};
assert_eq!(charging_state.as_deref(), Some("SuspendedEV"));
assert_eq!(*evse_id, Some(2));
assert_eq!(*connector_id, Some(1));
let start = observe_v16(&v1_6::CsRequest::StartTransaction(
v1_6::StartTransactionRequest::new(
2,
"CARD-1",
0,
DateTime::parse("2024-01-01T00:00:00Z").unwrap(),
),
));
let DomainEvent::TransactionStarted {
evse_id,
connector_id,
..
} = &start.event
else {
panic!("{:?}", start.event)
};
assert_eq!(*evse_id, None);
assert_eq!(*connector_id, Some(2));
let identity = crate::types::Identity::new("CS-0001").unwrap();
let mut ledger = super::super::ledger::Ledger::new();
let _ =
ledger.ingest_unsequenced(&to_ledger_event_with_id(&identity, &start, "42").unwrap());
let record = ledger.transaction(&identity, "42").unwrap();
assert_eq!(record.connector_id, Some(2));
assert_eq!(record.evse_id, None);
}
#[test]
fn the_oca_example_message_reaches_the_ledger_through_the_funnel() {
const BEGIN: &str = "{\"signedMeterData\": \"T0NNRnx7IlJEIjpbeyJSViI6MC4wMDAsIlJJIjoiMS1iOjEuOC4wIn1dfQ==\", \"encodingMethod\": \"OCMF\", \"publicKey\": \"MzA1OTMwMTMwNjA3MkE4NjQ4Q0UzRDAyMDEwNjA4MkE4NjQ4Q0UzRDAzMDEwNw==\"}";
const END: &str = "{\"signedMeterData\": \"T0NNRnx7IlJEIjpbeyJSViI6MC42MzYsIlJJIjoiMS1iOjEuOC4wIn1dfQ==\", \"encodingMethod\": \"OCMF\", \"publicKey\": \"MzA1OTMwMTMwNjA3MkE4NjQ4Q0UzRDAyMDEwNjA4MkE4NjQ4Q0UzRDAzMDEwNw==\"}";
let signed = |document: &str, context| {
v1_6::SampledValue::new(document)
.with_format(v1_6::ValueFormat::SignedData)
.with_measurand(v1_6::Measurand::EnergyActiveImportRegister)
.with_context(context)
};
let stop = v1_6::StopTransactionRequest::new(
108_814,
DateTime::parse("2024-01-01T01:00:00Z").unwrap(),
42,
)
.with_transaction_data(alloc::vec![v1_6::MeterValue::new(
DateTime::parse("2024-01-01T01:00:00Z").unwrap(),
alloc::vec![
signed(BEGIN, v1_6::ReadingContext::TransactionBegin),
signed(END, v1_6::ReadingContext::TransactionEnd),
],
)]);
let identity = crate::types::Identity::new("CS-0001").unwrap();
let observed = observe_v16(&v1_6::CsRequest::StopTransaction(stop));
let event = to_ledger_event(&identity, &observed).expect("a stop event");
let mut ledger = super::super::ledger::Ledger::new();
let _ = ledger.ingest_unsequenced(&event);
let record = ledger.transaction(&identity, "42").unwrap();
assert_eq!(record.signed.len(), 2);
let end = record
.signed_with_context("Transaction.End")
.next()
.expect("the end record");
assert_eq!(end.value.encoding_method.as_deref(), Some("OCMF"));
assert_eq!(
end.measurand.as_deref(),
Some("Energy.Active.Import.Register")
);
assert_eq!(
end.value.signed_meter_data,
"T0NNRnx7IlJEIjpbeyJSViI6MC42MzYsIlJJIjoiMS1iOjEuOC4wIn1dfQ=="
);
let key = end.value.public_key().unwrap().unwrap();
assert_eq!(key.shape, crate::metering::PublicKeyShape::PrintedHex);
assert_eq!(&key.bytes[..2], &[0x30, 0x59]);
assert_eq!(record.meter_stop_wh.unwrap().to_string(), "108814");
}
#[test]
fn a_signed_data_value_is_never_mistaken_for_a_reading() {
let values = alloc::vec![v1_6::MeterValue::new(
DateTime::parse("2024-01-01T00:00:00Z").unwrap(),
alloc::vec![
v1_6::SampledValue::new("{\"signedMeterData\":\"T0NNRnw=\"}")
.with_format(v1_6::ValueFormat::SignedData)
.with_measurand(v1_6::Measurand::EnergyActiveImportRegister),
v1_6::SampledValue::new("4500.5")
.with_measurand(v1_6::Measurand::EnergyActiveImportRegister),
],
)];
let observed = observe_v16(&v1_6::CsRequest::MeterValues(
v1_6::MeterValuesRequest::new(1, values),
));
let DomainEvent::MeterValues { energy, signed, .. } = &observed.event else {
panic!("{:?}", observed.event)
};
assert_eq!(energy.as_ref().unwrap().wh.to_string(), "4500.5");
assert_eq!(signed.len(), 1);
assert_eq!(signed[0].value.signed_meter_data, "T0NNRnw=");
}
#[test]
fn a_signed_register_reaches_the_ledger_record() {
let identity = crate::types::Identity::new("CS-0001").unwrap();
let signed = v2_1::SignedMeterValue::new("BASE64-OCMF", "OCMF")
.with_public_key("MzA1OQ==")
.with_signing_method("ECDSA-secp256r1-SHA256");
let request = v2_1::TransactionEventRequest::new(
v2_1::TransactionEventEnum::Ended,
DateTime::parse("2024-01-01T01:00:00Z").unwrap(),
v2_1::TriggerReason::StopAuthorized,
1,
v2_1::Transaction::new("tx-1"),
)
.with_meter_value(alloc::vec![v2_1::MeterValue::new(
alloc::vec![
v2_1::SampledValue::new(crate::decimal!(7300.250))
.with_measurand(v2_1::Measurand::EnergyActiveImportRegister)
.with_context(v2_1::ReadingContext::TransactionEnd)
.with_signed_meter_value(signed)
],
DateTime::parse("2024-01-01T01:00:00Z").unwrap(),
)]);
let observed = observe_v21(&v2_1::CsRequest::TransactionEvent(request));
let event = to_ledger_event(&identity, &observed).expect("transaction event");
let mut ledger = super::super::ledger::Ledger::new();
let _ = ledger.ingest(&event);
let record = ledger.transaction(&identity, "tx-1").unwrap();
let signed = record
.signed_with_context("Transaction.End")
.next()
.expect("the signed reading");
assert_eq!(signed.value.signed_meter_data, "BASE64-OCMF");
assert_eq!(signed.value.encoding_method.as_deref(), Some("OCMF"));
assert_eq!(
signed.value.signing_method.as_deref(),
Some("ECDSA-secp256r1-SHA256")
);
assert_eq!(
signed.value.public_key_bytes().unwrap().unwrap(),
alloc::vec![0x30, 0x59]
);
assert_eq!(record.meter_stop_wh.unwrap().to_string(), "7300.250");
assert_eq!(record.signed.len(), 1);
}
#[test]
fn a_21_transaction_event_becomes_a_ledger_entry() {
let identity = crate::types::Identity::new("CS-0001").unwrap();
let request = v2_1::TransactionEventRequest::new(
v2_1::TransactionEventEnum::Started,
DateTime::parse("2024-01-01T00:00:00Z").unwrap(),
v2_1::TriggerReason::Authorized,
0,
v2_1::Transaction::new("tx-1"),
);
let observed = observe_v21(&v2_1::CsRequest::TransactionEvent(request));
let event = to_ledger_event(&identity, &observed).expect("transaction event");
assert_eq!(event.transaction_id, "tx-1");
assert_eq!(event.kind, super::super::ledger::EventKind::Started);
let observed = observe_v21(&v2_1::CsRequest::Heartbeat(v2_1::HeartbeatRequest::new()));
assert!(to_ledger_event(&identity, &observed).is_none());
}
}