use serde::{Deserialize, Serialize};
use super::cdr::MeterValuesInBetween;
use crate::types::{
DateTime, EvseId, Extensions, Identification, Number, OperatorId, PartnerSessionId, SessionId, Text,
Validate, Validator, ViolationCode, strict_builder, validate_fields,
};
use crate::{oicp_enum, oicp_open_enum};
oicp_enum! {
pub enum ChargingNotificationType {
Start = "Start",
Progress = "Progress",
End = "End",
Error = "Error",
}
}
oicp_open_enum! {
pub enum ErrorType {
ConnectorError = "ConnectorError",
CriticalError = "CriticalError",
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, bon::Builder)]
#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
#[builder(finish_fn = build_unchecked)]
pub struct ChargingNotificationStart {
#[serde(rename = "Type")]
pub notification_type: ChargingNotificationType,
#[serde(rename = "SessionID")]
pub session_id: SessionId,
#[serde(rename = "CPOPartnerSessionID", default, skip_serializing_if = "Option::is_none")]
#[builder(into)]
pub cpo_partner_session_id: Option<PartnerSessionId>,
#[serde(rename = "EMPPartnerSessionID", default, skip_serializing_if = "Option::is_none")]
#[builder(into)]
pub emp_partner_session_id: Option<PartnerSessionId>,
#[serde(rename = "Identification", default, skip_serializing_if = "Option::is_none")]
pub identification: Option<Identification>,
#[serde(rename = "EvseID")]
pub evse_id: EvseId,
#[serde(rename = "ChargingStart")]
pub charging_start: DateTime,
#[serde(rename = "SessionStart", default, skip_serializing_if = "Option::is_none")]
pub session_start: Option<DateTime>,
#[serde(rename = "MeterValueStart", default, skip_serializing_if = "Option::is_none")]
pub meter_value_start: Option<Number>,
#[serde(rename = "OperatorID")]
pub operator_id: OperatorId,
#[serde(rename = "PartnerProductID", default, skip_serializing_if = "Option::is_none")]
#[builder(into)]
pub partner_product_id: Option<Text<50>>,
#[serde(flatten, default, skip_serializing_if = "Extensions::is_empty")]
#[builder(default)]
pub extensions: Extensions,
}
impl Validate for ChargingNotificationStart {
fn validate_in(&self, v: &mut Validator) {
check_type(v, self.notification_type, ChargingNotificationType::Start);
if let (Some(session_start), true) = (&self.session_start, self.charging_start.is_well_formed())
&& session_start.is_well_formed()
&& session_start > &self.charging_start
{
v.report_at(
"ChargingStart",
ViolationCode::Inconsistent,
"energy started flowing before the session began",
);
}
validate_fields!(
self,
v,
session_id as "SessionID",
cpo_partner_session_id as "CPOPartnerSessionID",
emp_partner_session_id as "EMPPartnerSessionID",
identification as "Identification",
evse_id as "EvseID",
charging_start as "ChargingStart",
session_start as "SessionStart",
meter_value_start as "MeterValueStart",
operator_id as "OperatorID",
partner_product_id as "PartnerProductID",
);
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, bon::Builder)]
#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
#[builder(finish_fn = build_unchecked)]
pub struct ChargingNotificationProgress {
#[serde(rename = "Type")]
pub notification_type: ChargingNotificationType,
#[serde(rename = "SessionID")]
pub session_id: SessionId,
#[serde(rename = "CPOPartnerSessionID", default, skip_serializing_if = "Option::is_none")]
#[builder(into)]
pub cpo_partner_session_id: Option<PartnerSessionId>,
#[serde(rename = "EMPPartnerSessionID", default, skip_serializing_if = "Option::is_none")]
#[builder(into)]
pub emp_partner_session_id: Option<PartnerSessionId>,
#[serde(rename = "Identification", default, skip_serializing_if = "Option::is_none")]
pub identification: Option<Identification>,
#[serde(rename = "EvseID")]
pub evse_id: EvseId,
#[serde(rename = "ChargingStart")]
pub charging_start: DateTime,
#[serde(rename = "EventOccurred")]
pub event_occurred: DateTime,
#[serde(rename = "ChargingDuration", default, skip_serializing_if = "Option::is_none")]
pub charging_duration: Option<i64>,
#[serde(rename = "SessionStart", default, skip_serializing_if = "Option::is_none")]
pub session_start: Option<DateTime>,
#[serde(rename = "ConsumedEnergyProgress", default, skip_serializing_if = "Option::is_none")]
pub consumed_energy_progress: Option<Number>,
#[serde(rename = "MeterValueStart", default, skip_serializing_if = "Option::is_none")]
pub meter_value_start: Option<Number>,
#[serde(rename = "MeterValueInBetween", default, skip_serializing_if = "Option::is_none")]
pub meter_value_in_between: Option<MeterValuesInBetween>,
#[serde(rename = "OperatorID")]
pub operator_id: OperatorId,
#[serde(rename = "PartnerProductID", default, skip_serializing_if = "Option::is_none")]
#[builder(into)]
pub partner_product_id: Option<Text<50>>,
#[serde(flatten, default, skip_serializing_if = "Extensions::is_empty")]
#[builder(default)]
pub extensions: Extensions,
}
impl ChargingNotificationProgress {
#[must_use]
pub fn implied_duration_ms(&self) -> Option<i64> {
(self.event_occurred.as_offset()? - self.charging_start.as_offset()?)
.whole_milliseconds()
.try_into()
.ok()
}
}
impl Validate for ChargingNotificationProgress {
fn validate_in(&self, v: &mut Validator) {
check_type(v, self.notification_type, ChargingNotificationType::Progress);
if self.charging_duration.is_none() && self.consumed_energy_progress.is_none() {
v.report(
ViolationCode::MissingConditional,
"a progress notification carries at least one of ChargingDuration or \
ConsumedEnergyProgress; with neither it tells the driver nothing",
);
}
if let (Some(stated), Some(implied)) = (self.charging_duration, self.implied_duration_ms()) {
if (stated - implied).abs() > 60_000 {
v.report_at(
"ChargingDuration",
ViolationCode::Inconsistent,
format!(
"ChargingDuration is {stated} ms, but EventOccurred - ChargingStart is {implied} ms"
),
);
}
}
if self.charging_duration.is_some_and(|d| d < 0) {
v.report_at("ChargingDuration", ViolationCode::OutOfRange, "a duration cannot be negative");
}
validate_fields!(
self,
v,
session_id as "SessionID",
cpo_partner_session_id as "CPOPartnerSessionID",
emp_partner_session_id as "EMPPartnerSessionID",
identification as "Identification",
evse_id as "EvseID",
charging_start as "ChargingStart",
event_occurred as "EventOccurred",
session_start as "SessionStart",
consumed_energy_progress as "ConsumedEnergyProgress",
meter_value_start as "MeterValueStart",
meter_value_in_between as "MeterValueInBetween",
operator_id as "OperatorID",
partner_product_id as "PartnerProductID",
);
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, bon::Builder)]
#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
#[builder(finish_fn = build_unchecked)]
pub struct ChargingNotificationEnd {
#[serde(rename = "Type")]
pub notification_type: ChargingNotificationType,
#[serde(rename = "SessionID")]
pub session_id: SessionId,
#[serde(rename = "CPOPartnerSessionID", default, skip_serializing_if = "Option::is_none")]
#[builder(into)]
pub cpo_partner_session_id: Option<PartnerSessionId>,
#[serde(rename = "EMPPartnerSessionID", default, skip_serializing_if = "Option::is_none")]
#[builder(into)]
pub emp_partner_session_id: Option<PartnerSessionId>,
#[serde(rename = "Identification", default, skip_serializing_if = "Option::is_none")]
pub identification: Option<Identification>,
#[serde(rename = "EvseID")]
pub evse_id: EvseId,
#[serde(rename = "ChargingStart", default, skip_serializing_if = "Option::is_none")]
pub charging_start: Option<DateTime>,
#[serde(rename = "ChargingEnd")]
pub charging_end: DateTime,
#[serde(rename = "SessionStart", default, skip_serializing_if = "Option::is_none")]
pub session_start: Option<DateTime>,
#[serde(rename = "SessionEnd", default, skip_serializing_if = "Option::is_none")]
pub session_end: Option<DateTime>,
#[serde(rename = "ConsumedEnergy", default, skip_serializing_if = "Option::is_none")]
pub consumed_energy: Option<Number>,
#[serde(rename = "MeterValueStart", default, skip_serializing_if = "Option::is_none")]
pub meter_value_start: Option<Number>,
#[serde(rename = "MeterValueEnd", default, skip_serializing_if = "Option::is_none")]
pub meter_value_end: Option<Number>,
#[serde(rename = "MeterValueInBetween", default, skip_serializing_if = "Option::is_none")]
pub meter_value_in_between: Option<MeterValuesInBetween>,
#[serde(rename = "OperatorID")]
pub operator_id: OperatorId,
#[serde(rename = "PartnerProductID", default, skip_serializing_if = "Option::is_none")]
#[builder(into)]
pub partner_product_id: Option<Text<50>>,
#[serde(rename = "PenaltyTimeStart", default, skip_serializing_if = "Option::is_none")]
pub penalty_time_start: Option<DateTime>,
#[serde(flatten, default, skip_serializing_if = "Extensions::is_empty")]
#[builder(default)]
pub extensions: Extensions,
}
impl Validate for ChargingNotificationEnd {
fn validate_in(&self, v: &mut Validator) {
check_type(v, self.notification_type, ChargingNotificationType::End);
if let (Some(start), Some(end), Some(consumed)) =
(self.meter_value_start, self.meter_value_end, self.consumed_energy)
&& end - start != consumed
{
v.report_at(
"ConsumedEnergy",
ViolationCode::Inconsistent,
format!("ConsumedEnergy is {consumed} but the meter readings differ by {}", end - start),
);
}
if let (Some(charging_start), true) = (&self.charging_start, self.charging_end.is_well_formed())
&& charging_start.is_well_formed()
&& charging_start > &self.charging_end
{
v.report_at("ChargingEnd", ViolationCode::Inconsistent, "charging ended before it started");
}
validate_fields!(
self,
v,
session_id as "SessionID",
cpo_partner_session_id as "CPOPartnerSessionID",
emp_partner_session_id as "EMPPartnerSessionID",
identification as "Identification",
evse_id as "EvseID",
charging_start as "ChargingStart",
charging_end as "ChargingEnd",
session_start as "SessionStart",
session_end as "SessionEnd",
consumed_energy as "ConsumedEnergy",
meter_value_start as "MeterValueStart",
meter_value_end as "MeterValueEnd",
meter_value_in_between as "MeterValueInBetween",
operator_id as "OperatorID",
partner_product_id as "PartnerProductID",
penalty_time_start as "PenaltyTimeStart",
);
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, bon::Builder)]
#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
#[builder(finish_fn = build_unchecked)]
pub struct ChargingNotificationError {
#[serde(rename = "Type")]
pub notification_type: ChargingNotificationType,
#[serde(rename = "SessionID")]
pub session_id: SessionId,
#[serde(rename = "CPOPartnerSessionID", default, skip_serializing_if = "Option::is_none")]
#[builder(into)]
pub cpo_partner_session_id: Option<PartnerSessionId>,
#[serde(rename = "EMPPartnerSessionID", default, skip_serializing_if = "Option::is_none")]
#[builder(into)]
pub emp_partner_session_id: Option<PartnerSessionId>,
#[serde(rename = "Identification", default, skip_serializing_if = "Option::is_none")]
pub identification: Option<Identification>,
#[serde(rename = "OperatorID")]
pub operator_id: OperatorId,
#[serde(rename = "EvseID")]
pub evse_id: EvseId,
#[serde(rename = "ErrorType")]
pub error_type: ErrorType,
#[serde(rename = "ErrorAdditionalInfo", default, skip_serializing_if = "Option::is_none")]
#[builder(into)]
pub error_additional_info: Option<Text<250>>,
#[serde(flatten, default, skip_serializing_if = "Extensions::is_empty")]
#[builder(default)]
pub extensions: Extensions,
}
impl Validate for ChargingNotificationError {
fn validate_in(&self, v: &mut Validator) {
check_type(v, self.notification_type, ChargingNotificationType::Error);
validate_fields!(
self,
v,
session_id as "SessionID",
cpo_partner_session_id as "CPOPartnerSessionID",
emp_partner_session_id as "EMPPartnerSessionID",
identification as "Identification",
operator_id as "OperatorID",
evse_id as "EvseID",
error_type as "ErrorType",
error_additional_info as "ErrorAdditionalInfo",
);
}
}
fn check_type(v: &mut Validator, actual: ChargingNotificationType, expected: ChargingNotificationType) {
if actual != expected {
v.report_at(
"Type",
ViolationCode::Inconsistent,
format!("this is a {expected} notification, but Type says {actual}"),
);
}
}
#[derive(Clone, Debug, PartialEq)]
#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
pub enum ChargingNotification {
Start(ChargingNotificationStart),
Progress(ChargingNotificationProgress),
End(ChargingNotificationEnd),
Error(ChargingNotificationError),
}
impl ChargingNotification {
#[must_use]
pub const fn notification_type(&self) -> ChargingNotificationType {
match self {
Self::Start(_) => ChargingNotificationType::Start,
Self::Progress(_) => ChargingNotificationType::Progress,
Self::End(_) => ChargingNotificationType::End,
Self::Error(_) => ChargingNotificationType::Error,
}
}
#[must_use]
pub fn session_id(&self) -> &SessionId {
match self {
Self::Start(n) => &n.session_id,
Self::Progress(n) => &n.session_id,
Self::End(n) => &n.session_id,
Self::Error(n) => &n.session_id,
}
}
#[must_use]
pub fn evse_id(&self) -> &EvseId {
match self {
Self::Start(n) => &n.evse_id,
Self::Progress(n) => &n.evse_id,
Self::End(n) => &n.evse_id,
Self::Error(n) => &n.evse_id,
}
}
#[must_use]
pub fn operator_id(&self) -> &OperatorId {
match self {
Self::Start(n) => &n.operator_id,
Self::Progress(n) => &n.operator_id,
Self::End(n) => &n.operator_id,
Self::Error(n) => &n.operator_id,
}
}
}
impl Validate for ChargingNotification {
fn validate_in(&self, v: &mut Validator) {
match self {
Self::Start(n) => n.validate_in(v),
Self::Progress(n) => n.validate_in(v),
Self::End(n) => n.validate_in(v),
Self::Error(n) => n.validate_in(v),
}
}
}
impl Serialize for ChargingNotification {
fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
match self {
Self::Start(n) => n.serialize(s),
Self::Progress(n) => n.serialize(s),
Self::End(n) => n.serialize(s),
Self::Error(n) => n.serialize(s),
}
}
}
impl<'de> Deserialize<'de> for ChargingNotification {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
use serde::de::Error as _;
let value = serde_json::Value::deserialize(d)?;
let tag = value
.get("Type")
.and_then(serde_json::Value::as_str)
.ok_or_else(|| D::Error::missing_field("Type"))?;
let notification_type: ChargingNotificationType = tag.parse().map_err(D::Error::custom)?;
macro_rules! parse {
($variant:ident) => {
Self::$variant(serde_json::from_value(value).map_err(D::Error::custom)?)
};
}
Ok(match notification_type {
ChargingNotificationType::Start => parse!(Start),
ChargingNotificationType::Progress => parse!(Progress),
ChargingNotificationType::End => parse!(End),
ChargingNotificationType::Error => parse!(Error),
})
}
}
strict_builder!(
ChargingNotificationStart,
ChargingNotificationStartBuilder,
charging_notification_start_builder
);
strict_builder!(
ChargingNotificationProgress,
ChargingNotificationProgressBuilder,
charging_notification_progress_builder
);
strict_builder!(ChargingNotificationEnd, ChargingNotificationEndBuilder, charging_notification_end_builder);
strict_builder!(
ChargingNotificationError,
ChargingNotificationErrorBuilder,
charging_notification_error_builder
);
#[cfg(test)]
mod tests {
use super::*;
fn progress() -> ChargingNotificationProgress {
ChargingNotificationProgress {
notification_type: ChargingNotificationType::Progress,
session_id: "f98efba4-02d8-4fa0-b810-9a9d50d2c527".parse().unwrap(),
cpo_partner_session_id: None,
emp_partner_session_id: None,
identification: None,
evse_id: "DE*XYZ*ETEST1".parse().unwrap(),
charging_start: "2020-09-23T14:17:53.038Z".parse().unwrap(),
event_occurred: "2020-09-23T14:25:53.038Z".parse().unwrap(),
charging_duration: Some(480_000),
session_start: None,
consumed_energy_progress: Some("9".parse().unwrap()),
meter_value_start: Some(Number::ZERO),
meter_value_in_between: None,
operator_id: "DE*ABC".parse().unwrap(),
partner_product_id: None,
extensions: Extensions::new(),
}
}
#[test]
fn the_notification_union_dispatches_on_the_type_tag() {
let json = serde_json::to_string(&ChargingNotification::Progress(progress())).unwrap();
assert!(json.contains(r#""Type":"Progress""#));
let back: ChargingNotification = serde_json::from_str(&json).unwrap();
assert_eq!(back.notification_type(), ChargingNotificationType::Progress);
assert_eq!(back.evse_id().as_str(), "DE*XYZ*ETEST1");
}
#[test]
fn a_progress_notification_with_neither_figure_says_nothing() {
let mut n = progress();
n.charging_duration = None;
n.consumed_energy_progress = None;
assert_eq!(n.validate().unwrap_err().as_slice()[0].code, ViolationCode::MissingConditional);
}
#[test]
fn a_duration_that_contradicts_the_timestamps_is_reported() {
let n = progress();
assert_eq!(n.implied_duration_ms(), Some(480_000));
assert!(n.validate().is_ok());
let wrong = ChargingNotificationProgress { charging_duration: Some(48_000), ..progress() };
let err = wrong.validate().unwrap_err();
assert_eq!(err.as_slice()[0].pointer, "/ChargingDuration");
}
#[test]
fn clock_skew_within_a_minute_is_tolerated() {
let n = ChargingNotificationProgress { charging_duration: Some(480_000 + 30_000), ..progress() };
assert!(n.validate().is_ok(), "half a minute of skew is not a spec violation");
}
#[test]
fn a_mislabelled_notification_is_reported() {
let n =
ChargingNotificationProgress { notification_type: ChargingNotificationType::Start, ..progress() };
assert!(n.validate().unwrap_err().iter().any(|x| x.pointer == "/Type"));
}
}