use std::collections::BTreeMap;
use crate::cpo::{EvseDataRecord, OperatorEvseData, PushEvseDataRequest};
use crate::types::{ActionType, Extensions, OperatorId, Text};
#[derive(Clone, Debug, PartialEq)]
pub struct PushPlan {
pub inserts: Vec<EvseDataRecord>,
pub updates: Vec<EvseDataRecord>,
pub deletes: Vec<EvseDataRecord>,
pub unchanged: u64,
}
impl PushPlan {
#[must_use]
pub fn is_empty(&self) -> bool {
self.inserts.is_empty() && self.updates.is_empty() && self.deletes.is_empty()
}
#[must_use]
pub fn record_count(&self) -> usize {
self.inserts.len() + self.updates.len() + self.deletes.len()
}
#[must_use]
pub fn into_requests(
self,
operator_id: &OperatorId,
operator_name: &Text<100>,
) -> Vec<PushEvseDataRequest> {
let mut requests = Vec::with_capacity(3);
for (action, records) in [
(ActionType::Insert, self.inserts),
(ActionType::Update, self.updates),
(ActionType::Delete, self.deletes),
] {
if !records.is_empty() {
requests.push(PushEvseDataRequest {
action_type: action,
operator_evse_data: OperatorEvseData {
operator_id: operator_id.clone(),
operator_name: operator_name.clone(),
evse_data_record: records,
extensions: Extensions::new(),
},
});
}
}
requests
}
}
#[derive(Clone, Copy, Debug)]
pub struct PushPlanner;
impl PushPlanner {
#[must_use]
pub fn plan(previous: &[EvseDataRecord], current: &[EvseDataRecord]) -> PushPlan {
let before: BTreeMap<String, &EvseDataRecord> =
previous.iter().map(|r| (r.evse_id.canonical(), r)).collect();
let after: BTreeMap<String, &EvseDataRecord> =
current.iter().map(|r| (r.evse_id.canonical(), r)).collect();
let mut plan = PushPlan { inserts: vec![], updates: vec![], deletes: vec![], unchanged: 0 };
for (key, record) in &after {
match before.get(key) {
None => plan.inserts.push((*record).clone()),
Some(existing) if !records_equal(existing, record) => plan.updates.push((*record).clone()),
Some(_) => plan.unchanged += 1,
}
}
for (key, record) in &before {
if !after.contains_key(key) {
plan.deletes.push((*record).clone());
}
}
plan
}
#[must_use]
pub fn full_load(
operator_id: OperatorId,
operator_name: Text<100>,
records: Vec<EvseDataRecord>,
) -> PushEvseDataRequest {
PushEvseDataRequest {
action_type: ActionType::FullLoad,
operator_evse_data: OperatorEvseData {
operator_id,
operator_name,
evse_data_record: records,
extensions: Extensions::new(),
},
}
}
}
fn records_equal(a: &EvseDataRecord, b: &EvseDataRecord) -> bool {
let normalise = |r: &EvseDataRecord| {
let mut copy = r.clone();
copy.delta_type = None;
copy.last_update = None;
copy
};
normalise(a) == normalise(b)
}
#[cfg(all(test, feature = "testkit"))]
mod tests {
use super::*;
use crate::testkit::samples;
use crate::types::DateTime;
#[test]
fn a_plan_reports_emptiness_and_size_honestly() {
let one = samples::evse_data_record("DE*ABC*E1");
let two = samples::evse_data_record("DE*ABC*E2");
let three = samples::evse_data_record("DE*ABC*E3");
let nothing = PushPlanner::plan(std::slice::from_ref(&one), std::slice::from_ref(&one));
assert!(nothing.is_empty());
assert_eq!(nothing.record_count(), 0);
assert_eq!(nothing.unchanged, 1);
let mut changed = two.clone();
changed.charging_station_id = Some(crate::types::Text::new_unchecked("moved"));
let plan = PushPlanner::plan(&[one.clone(), two], &[one, changed, three.clone()]);
assert_eq!((plan.inserts.len(), plan.updates.len(), plan.deletes.len()), (1, 1, 0));
assert!(!plan.is_empty());
assert_eq!(plan.record_count(), 2);
for plan in [
PushPlan { inserts: vec![three.clone()], updates: vec![], deletes: vec![], unchanged: 0 },
PushPlan { inserts: vec![], updates: vec![three.clone()], deletes: vec![], unchanged: 0 },
PushPlan { inserts: vec![], updates: vec![], deletes: vec![three.clone()], unchanged: 0 },
] {
assert!(!plan.is_empty(), "a plan with work to do is not empty");
assert_eq!(plan.record_count(), 1);
}
}
#[test]
fn an_unchanged_fleet_produces_no_requests() {
let fleet = vec![samples::evse_data_record("DE*ABC*E1"), samples::evse_data_record("DE*ABC*E2")];
let plan = PushPlanner::plan(&fleet, &fleet);
assert!(plan.is_empty());
assert_eq!(plan.unchanged, 2);
assert!(plan.into_requests(&"DE*ABC".parse().unwrap(), &Text::new("ABC").unwrap()).is_empty());
}
#[test]
fn hubjects_own_fields_do_not_count_as_a_change() {
let previous = vec![samples::evse_data_record("DE*ABC*E1")];
let mut current = previous.clone();
current[0].last_update = Some(DateTime::now());
current[0].delta_type = Some(crate::cpo::DeltaType::Update);
let plan = PushPlanner::plan(&previous, ¤t);
assert!(plan.is_empty(), "only Hubject's own fields differ");
assert_eq!(plan.unchanged, 1);
}
#[test]
fn a_real_change_produces_exactly_one_update() {
let previous = vec![samples::evse_data_record("DE*ABC*E1")];
let mut current = previous.clone();
current[0].is_hubject_compatible = false;
let plan = PushPlanner::plan(&previous, ¤t);
assert_eq!(plan.updates.len(), 1);
assert_eq!(plan.inserts.len(), 0);
assert_eq!(plan.deletes.len(), 0);
}
#[test]
fn requests_send_deletions_last() {
let previous = vec![samples::evse_data_record("DE*ABC*E1"), samples::evse_data_record("DE*ABC*E2")];
let current = vec![samples::evse_data_record("DE*ABC*E3")];
let plan = PushPlanner::plan(&previous, ¤t);
let requests = plan.into_requests(&"DE*ABC".parse().unwrap(), &Text::new("ABC").unwrap());
let actions: Vec<_> = requests.iter().map(|r| r.action_type).collect();
assert_eq!(actions, vec![ActionType::Insert, ActionType::Delete]);
assert!(!actions.iter().any(|a| a.is_destructive_replace()));
}
#[test]
fn a_change_of_identifier_spelling_is_not_a_fleet_replacement() {
let previous = vec![samples::evse_data_record("DE*ABC*E1")];
let current = vec![samples::evse_data_record("DEABCE1")];
let plan = PushPlanner::plan(&previous, ¤t);
assert!(plan.deletes.is_empty(), "the old spelling must not be deleted");
assert_eq!(plan.unchanged + plan.updates.len() as u64, 1);
}
#[test]
fn full_load_is_reachable_only_by_its_own_name() {
let request = PushPlanner::full_load(
"DE*ABC".parse().unwrap(),
Text::new("ABC").unwrap(),
vec![samples::evse_data_record("DE*ABC*E1")],
);
assert!(request.action_type.is_destructive_replace());
}
}