///|
pub(all) enum RemoteCommandStatus {
Accepted
Rejected
} derive(Eq, @debug.Debug)
///|
fn remote_command_status(
value : String,
) -> RemoteCommandStatus raise ProtocolFailure {
match value {
"Accepted" => Accepted
"Rejected" => Rejected
_ => refuse(UnsupportedValue("status", value))
}
}
///|
fn remote_command_status_name(value : RemoteCommandStatus) -> String {
match value {
Accepted => "Accepted"
Rejected => "Rejected"
}
}
///|
pub(all) struct RemoteStartTransactionRequest {
id_tag : String
connector_id : Int32?
charging_profile : ChargingProfile?
} derive(Eq, @debug.Debug)
///|
fn parse_remote_start(
value : Json,
) -> RemoteStartTransactionRequest raise ProtocolFailure {
let id_tag = required_string(value, "idTag")
if id_tag.is_empty() {
refuse(InvalidField("idTag"))
}
let fields = match value {
Json::Object(fields) => fields
_ => refuse(InvalidPayload)
}
let charging_profile = match fields.get("chargingProfile") {
None | Some(Json::Null) => None
Some(profile) => Some(parse_charging_profile(profile))
}
{
id_tag,
connector_id: optional_nonnegative_int(value, "connectorId"),
charging_profile,
}
}
///|
pub fn RemoteStartTransactionRequest::from_json(
value : Json,
) -> Result[RemoteStartTransactionRequest, ProtocolError] {
result_of(() => parse_remote_start(value))
}
///|
pub fn RemoteStartTransactionRequest::to_json(
self : RemoteStartTransactionRequest,
) -> Json {
let fields : Map[String, Json] = { "idTag": Json::string(self.id_tag) }
match self.connector_id {
Some(value) => fields.set("connectorId", int_json(value))
None => ()
}
match self.charging_profile {
Some(profile) => fields.set("chargingProfile", profile.to_json())
None => ()
}
Json::object(fields)
}
///|
pub(all) struct RemoteStartTransactionResponse {
status : RemoteCommandStatus
} derive(Eq, @debug.Debug)
///|
fn parse_remote_start_response(
value : Json,
) -> RemoteStartTransactionResponse raise ProtocolFailure {
{ status: remote_command_status(required_string(value, "status")), }
}
///|
pub fn RemoteStartTransactionResponse::from_json(
value : Json,
) -> Result[RemoteStartTransactionResponse, ProtocolError] {
result_of(() => parse_remote_start_response(value))
}
///|
pub fn RemoteStartTransactionResponse::to_json(
self : RemoteStartTransactionResponse,
) -> Json {
Json::object({
"status": Json::string(remote_command_status_name(self.status)),
})
}
///|
pub(all) struct RemoteStopTransactionRequest {
transaction_id : Int32
} derive(Eq, @debug.Debug)
///|
fn parse_remote_stop(
value : Json,
) -> RemoteStopTransactionRequest raise ProtocolFailure {
{ transaction_id: required_nonnegative_int(value, "transactionId"), }
}
///|
pub fn RemoteStopTransactionRequest::from_json(
value : Json,
) -> Result[RemoteStopTransactionRequest, ProtocolError] {
result_of(() => parse_remote_stop(value))
}
///|
pub fn RemoteStopTransactionRequest::to_json(
self : RemoteStopTransactionRequest,
) -> Json {
Json::object({ "transactionId": int_json(self.transaction_id) })
}
///|
pub(all) struct RemoteStopTransactionResponse {
status : RemoteCommandStatus
} derive(Eq, @debug.Debug)
///|
fn parse_remote_stop_response(
value : Json,
) -> RemoteStopTransactionResponse raise ProtocolFailure {
{ status: remote_command_status(required_string(value, "status")), }
}
///|
pub fn RemoteStopTransactionResponse::from_json(
value : Json,
) -> Result[RemoteStopTransactionResponse, ProtocolError] {
result_of(() => parse_remote_stop_response(value))
}
///|
pub fn RemoteStopTransactionResponse::to_json(
self : RemoteStopTransactionResponse,
) -> Json {
Json::object({
"status": Json::string(remote_command_status_name(self.status)),
})
}