use super::http::{ClientConfig, Transport, warn_on_identity_mismatch};
use super::identity::{ClientIdentity, IdentityWarning};
use crate::cpo::{
AuthorizationStartResponse, AuthorizationStopResponse, AuthorizeStartRequest, AuthorizeStopRequest,
ChargeDetailRecord, ChargingNotification, EvseDataRecord, EvseStatusRecord, OperatorEvseData,
OperatorEvseStatus, PushEvseDataRequest, PushEvsePricingRequest, PushEvseStatusRequest,
PushPricingProductDataRequest,
};
use crate::sync::{PushPlan, PushPlanner};
use crate::transport::{HubjectEnv, OicpError, Operation, PathId, Result};
use crate::types::{Acknowledgement, ActionType, Extensions, OperatorId, Text};
#[derive(Debug, Clone)]
pub struct CpoClient {
transport: Transport,
operator_id: OperatorId,
identity_warning: Option<IdentityWarning>,
}
#[derive(Default)]
pub struct CpoClientBuilder {
environment: Option<HubjectEnv>,
operator_id: Option<OperatorId>,
identity: Option<ClientIdentity>,
config: Option<ClientConfig>,
}
impl CpoClientBuilder {
#[must_use]
pub fn environment(mut self, environment: HubjectEnv) -> Self {
self.environment = Some(environment);
self
}
#[must_use]
pub fn operator_id(mut self, operator_id: OperatorId) -> Self {
self.operator_id = Some(operator_id);
self
}
#[must_use]
pub fn identity(mut self, identity: ClientIdentity) -> Self {
self.identity = Some(identity);
self
}
#[must_use]
pub fn config(mut self, config: ClientConfig) -> Self {
self.config = Some(config);
self
}
pub fn build(self) -> Result<CpoClient> {
let operator_id = self.operator_id.ok_or_else(|| {
OicpError::transport("a CpoClient needs an OperatorID: it goes in every URL path")
})?;
let mut config = self.config.unwrap_or_default();
if let Some(environment) = self.environment {
config.environment = environment;
}
let identity_warning = warn_on_identity_mismatch(self.identity.as_ref(), operator_id.as_str());
let transport = Transport::new(config, self.identity.as_ref())?;
Ok(CpoClient { transport, operator_id, identity_warning })
}
}
impl CpoClient {
#[must_use]
pub fn builder() -> CpoClientBuilder {
CpoClientBuilder::default()
}
#[must_use]
pub const fn operator_id(&self) -> &OperatorId {
&self.operator_id
}
#[must_use]
pub const fn transport(&self) -> &Transport {
&self.transport
}
#[must_use]
pub const fn identity_warning(&self) -> Option<&IdentityWarning> {
self.identity_warning.as_ref()
}
fn path_id(&self) -> PathId {
PathId::Operator(self.operator_id.clone())
}
pub async fn push_evse_data(&self, request: &PushEvseDataRequest) -> Result<Acknowledgement> {
self.transport.post(Operation::PushEvseData, &self.path_id(), request).await
}
pub async fn push_evse_data_insert(
&self,
records: Vec<EvseDataRecord>,
operator_name: impl Into<String>,
) -> Result<Acknowledgement> {
self.push_with_action(ActionType::Insert, records, operator_name).await
}
pub async fn push_evse_data_update(
&self,
records: Vec<EvseDataRecord>,
operator_name: impl Into<String>,
) -> Result<Acknowledgement> {
self.push_with_action(ActionType::Update, records, operator_name).await
}
pub async fn push_evse_data_delete(
&self,
records: Vec<EvseDataRecord>,
operator_name: impl Into<String>,
) -> Result<Acknowledgement> {
self.push_with_action(ActionType::Delete, records, operator_name).await
}
pub async fn push_evse_data_plan(
&self,
plan: PushPlan,
operator_name: impl Into<String>,
) -> Result<Vec<Acknowledgement>> {
let name = Text::new_unchecked(operator_name.into());
let mut acknowledgements = vec![];
for request in plan.into_requests(&self.operator_id, &name) {
acknowledgements.push(self.push_evse_data(&request).await?);
}
Ok(acknowledgements)
}
pub async fn push_evse_data_full_load(
&self,
records: Vec<EvseDataRecord>,
operator_name: impl Into<String>,
) -> Result<Acknowledgement> {
if self.transport.is_production() {
tracing::warn!(
target: "oicp_kit::client",
operator = %self.operator_id,
records = records.len(),
"sending a fullLoad to the production brokering system: every charging point of this \
operator that is not in this push will be withdrawn from the roaming network"
);
}
let request = PushPlanner::full_load(
self.operator_id.clone(),
Text::new_unchecked(operator_name.into()),
records,
);
self.push_evse_data(&request).await
}
async fn push_with_action(
&self,
action_type: ActionType,
records: Vec<EvseDataRecord>,
operator_name: impl Into<String>,
) -> Result<Acknowledgement> {
let request = PushEvseDataRequest {
action_type,
operator_evse_data: OperatorEvseData {
operator_id: self.operator_id.clone(),
operator_name: Text::new_unchecked(operator_name.into()),
evse_data_record: records,
extensions: Extensions::new(),
},
};
self.push_evse_data(&request).await
}
pub async fn push_evse_status(&self, request: &PushEvseStatusRequest) -> Result<Acknowledgement> {
self.transport.post(Operation::PushEvseStatus, &self.path_id(), request).await
}
pub async fn update_evse_status(&self, records: Vec<EvseStatusRecord>) -> Result<Acknowledgement> {
let request = PushEvseStatusRequest {
action_type: ActionType::Update,
operator_evse_status: OperatorEvseStatus {
operator_id: self.operator_id.clone(),
operator_name: None,
evse_status_record: records,
extensions: Extensions::new(),
},
};
self.push_evse_status(&request).await
}
pub async fn authorize_start(
&self,
request: &AuthorizeStartRequest,
) -> Result<AuthorizationStartResponse> {
self.transport.post(Operation::AuthorizeStart, &self.path_id(), request).await
}
pub async fn authorize_stop(&self, request: &AuthorizeStopRequest) -> Result<AuthorizationStopResponse> {
self.transport.post(Operation::AuthorizeStop, &self.path_id(), request).await
}
pub async fn send_charge_detail_record(&self, cdr: &ChargeDetailRecord) -> Result<Acknowledgement> {
self.transport.post(Operation::ChargeDetailRecord, &self.path_id(), cdr).await
}
pub async fn send_charging_notification(
&self,
notification: &ChargingNotification,
) -> Result<Acknowledgement> {
self.transport.post(Operation::ChargingNotifications, &self.path_id(), notification).await
}
pub async fn push_pricing_product_data(
&self,
request: &PushPricingProductDataRequest,
) -> Result<Acknowledgement> {
self.transport.post(Operation::PushPricingProductData, &self.path_id(), request).await
}
pub async fn push_evse_pricing(&self, request: &PushEvsePricingRequest) -> Result<Acknowledgement> {
self.transport.post(Operation::PushEvsePricing, &self.path_id(), request).await
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_client_without_an_operator_id_says_why_it_cannot_be_built() {
let err = CpoClient::builder().build().unwrap_err();
assert!(err.to_string().contains("OperatorID"), "{err}");
}
#[test]
fn a_client_builds_and_keeps_its_identifier_verbatim() {
let client = CpoClient::builder()
.operator_id("DE*ABC".parse().unwrap())
.environment(HubjectEnv::Qa)
.build()
.unwrap();
assert_eq!(client.operator_id().as_str(), "DE*ABC");
assert!(client.identity_warning().is_none(), "no certificate was configured to check against");
assert!(!client.transport().is_production());
}
}