use alloc::vec::Vec;
use bon::Builder;
use serde::{Deserialize, Serialize};
use super::common::PowerForecastValue;
use super::{Duration, Id, Timestamp};
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum PowerSequenceStatus {
NotScheduled,
Scheduled,
Executing,
Interrupted,
Finished,
Aborted,
}
impl PowerSequenceStatus {
#[must_use]
pub const fn has_selection(self) -> bool {
!matches!(self, Self::NotScheduled)
}
#[must_use]
pub const fn has_started(self) -> bool {
matches!(
self,
Self::Executing | Self::Interrupted | Self::Finished | Self::Aborted
)
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct PowerSequenceElement {
pub duration: Duration,
pub power_values: Vec<PowerForecastValue>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Builder)]
#[serde(deny_unknown_fields)]
pub struct PowerSequence {
pub id: Id,
pub elements: Vec<PowerSequenceElement>,
pub is_interruptible: bool,
#[serde(skip_serializing_if = "Option::is_none")]
pub max_pause_before: Option<Duration>,
pub abnormal_condition_only: bool,
}
impl PowerSequence {
#[must_use]
pub fn total_duration(&self) -> Duration {
self.elements.iter().fold(Duration::ZERO, |acc, e| {
acc.checked_add(e.duration).unwrap_or(acc)
})
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Builder)]
#[serde(deny_unknown_fields)]
pub struct PowerSequenceContainer {
pub id: Id,
pub power_sequences: Vec<PowerSequence>,
}
impl PowerSequenceContainer {
#[must_use]
pub fn sequence(&self, id: &Id) -> Option<&PowerSequence> {
self.power_sequences.iter().find(|s| s.id == *id)
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Builder)]
#[serde(deny_unknown_fields)]
pub struct PowerSequenceContainerStatus {
pub power_profile_id: Id,
pub sequence_container_id: Id,
#[serde(skip_serializing_if = "Option::is_none")]
pub selected_sequence_id: Option<Id>,
#[serde(skip_serializing_if = "Option::is_none")]
pub progress: Option<Duration>,
pub status: PowerSequenceStatus,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Builder)]
#[serde(deny_unknown_fields)]
pub struct PowerProfileDefinition {
#[cfg_attr(feature = "uuid", builder(default = Id::generate()))]
pub message_id: Id,
pub id: Id,
pub start_time: Timestamp,
pub end_time: Timestamp,
#[serde(rename = "power_sequences_containers")]
pub power_sequence_containers: Vec<PowerSequenceContainer>,
}
impl PowerProfileDefinition {
#[must_use]
pub fn container(&self, id: &Id) -> Option<&PowerSequenceContainer> {
self.power_sequence_containers.iter().find(|c| c.id == *id)
}
#[must_use]
pub fn resolve(
&self,
container_id: &Id,
sequence_id: &Id,
) -> Option<(&PowerSequenceContainer, &PowerSequence)> {
let container = self.container(container_id)?;
let sequence = container.sequence(sequence_id)?;
Some((container, sequence))
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Builder)]
#[serde(deny_unknown_fields)]
pub struct PowerProfileStatus {
#[cfg_attr(feature = "uuid", builder(default = Id::generate()))]
pub message_id: Id,
pub sequence_container_status: Vec<PowerSequenceContainerStatus>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Builder)]
#[serde(deny_unknown_fields)]
pub struct ScheduleInstruction {
#[cfg_attr(feature = "uuid", builder(default = Id::generate()))]
pub message_id: Id,
pub id: Id,
pub power_profile_id: Id,
pub sequence_container_id: Id,
pub power_sequence_id: Id,
pub execution_time: Timestamp,
pub abnormal_condition: bool,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Builder)]
#[serde(deny_unknown_fields)]
pub struct StartInterruptionInstruction {
#[cfg_attr(feature = "uuid", builder(default = Id::generate()))]
pub message_id: Id,
pub id: Id,
pub power_profile_id: Id,
pub sequence_container_id: Id,
pub power_sequence_id: Id,
pub execution_time: Timestamp,
pub abnormal_condition: bool,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Builder)]
#[serde(deny_unknown_fields)]
pub struct EndInterruptionInstruction {
#[cfg_attr(feature = "uuid", builder(default = Id::generate()))]
pub message_id: Id,
pub id: Id,
pub power_profile_id: Id,
pub sequence_container_id: Id,
pub power_sequence_id: Id,
pub execution_time: Timestamp,
pub abnormal_condition: bool,
}
#[cfg(test)]
mod tests {
use super::*;
use crate::types::common::CommodityQuantity;
fn sequence(id: &str, seconds: u64) -> PowerSequence {
PowerSequence {
id: Id::parse(id).unwrap(),
elements: alloc::vec![PowerSequenceElement {
duration: Duration::from_secs(seconds),
power_values: alloc::vec![PowerForecastValue::expected(
2000.0,
CommodityQuantity::ElectricPowerL1
)],
}],
is_interruptible: false,
max_pause_before: None,
abnormal_condition_only: false,
}
}
#[test]
fn the_container_plural_is_on_the_wire_but_not_in_rust() {
let profile = PowerProfileDefinition {
message_id: Id::new_const("m1"),
id: Id::new_const("profile1"),
start_time: Timestamp::UNIX_EPOCH,
end_time: Timestamp::UNIX_EPOCH,
power_sequence_containers: alloc::vec![PowerSequenceContainer {
id: Id::new_const("c1"),
power_sequences: alloc::vec![sequence("s1", 3600)],
}],
};
let json = serde_json::to_string(&profile).unwrap();
assert!(json.contains("\"power_sequences_containers\""));
let back: PowerProfileDefinition = serde_json::from_str(&json).unwrap();
assert_eq!(back, profile);
}
#[test]
fn resolving_an_instruction_needs_both_ids() {
let profile = PowerProfileDefinition {
message_id: Id::new_const("m1"),
id: Id::new_const("profile1"),
start_time: Timestamp::UNIX_EPOCH,
end_time: Timestamp::UNIX_EPOCH,
power_sequence_containers: alloc::vec![PowerSequenceContainer {
id: Id::new_const("c1"),
power_sequences: alloc::vec![sequence("s1", 3600), sequence("s2", 7200)],
}],
};
let (container, seq) = profile
.resolve(&Id::new_const("c1"), &Id::new_const("s2"))
.unwrap();
assert_eq!(container.id, "c1");
assert_eq!(seq.total_duration(), Duration::from_secs(7200));
assert!(
profile
.resolve(&Id::new_const("c9"), &Id::new_const("s1"))
.is_none()
);
assert!(
profile
.resolve(&Id::new_const("c1"), &Id::new_const("s9"))
.is_none()
);
}
#[test]
fn progress_is_required_exactly_once_a_sequence_has_started() {
assert!(!PowerSequenceStatus::NotScheduled.has_started());
assert!(!PowerSequenceStatus::Scheduled.has_started());
assert!(PowerSequenceStatus::Executing.has_started());
assert!(PowerSequenceStatus::Interrupted.has_started());
assert!(PowerSequenceStatus::Finished.has_started());
assert!(PowerSequenceStatus::Aborted.has_started());
assert!(!PowerSequenceStatus::NotScheduled.has_selection());
assert!(PowerSequenceStatus::Scheduled.has_selection());
}
}