1use crate::message::MessageKind;
14use crate::types::common::{ControlType, EnergyManagementRole};
15
16#[derive(Debug, Clone, Copy, PartialEq, Eq)]
18pub enum Allowance {
19 Yes,
21 WrongState,
23 WrongRole,
25}
26
27impl Allowance {
28 #[must_use]
30 pub const fn is_allowed(self) -> bool {
31 matches!(self, Allowance::Yes)
32 }
33}
34
35#[must_use]
41pub fn allowed(
42 active: Option<ControlType>,
43 sender: EnergyManagementRole,
44 kind: MessageKind,
45) -> Allowance {
46 use MessageKind as K;
47
48 if let Some(expected) = kind.sender()
49 && expected != sender
50 {
51 return Allowance::WrongRole;
52 }
53
54 let active = active.filter(|c| c.is_controllable());
55
56 #[allow(clippy::match_same_arms)]
59 match kind {
60 K::ReceptionStatus | K::SessionRequest => Allowance::Yes,
62
63 K::Handshake | K::HandshakeResponse => {
66 if active.is_none() {
67 Allowance::Yes
68 } else {
69 Allowance::WrongState
70 }
71 }
72
73 K::ResourceManagerDetails
77 | K::PowerMeasurement
78 | K::PowerForecast
79 | K::SelectControlType => Allowance::Yes,
80
81 K::InstructionStatusUpdate | K::RevokeObject => {
83 if active.is_some() {
84 Allowance::Yes
85 } else {
86 Allowance::WrongState
87 }
88 }
89
90 _ => match (kind.control_type(), active) {
92 (Some(needed), Some(current)) if needed == current => Allowance::Yes,
93 _ => Allowance::WrongState,
94 },
95 }
96}
97
98#[must_use]
100pub fn allowed_kinds(
101 active: Option<ControlType>,
102 sender: EnergyManagementRole,
103) -> alloc::vec::Vec<MessageKind> {
104 MessageKind::ALL
105 .iter()
106 .copied()
107 .filter(|k| allowed(active, sender, *k).is_allowed())
108 .collect()
109}
110
111#[cfg(test)]
112mod tests {
113 use super::*;
114 use EnergyManagementRole::{Cem, Rm};
115 use alloc::vec::Vec;
116
117 fn names(active: Option<ControlType>, sender: EnergyManagementRole) -> Vec<&'static str> {
118 let mut v: Vec<_> = allowed_kinds(active, sender)
119 .into_iter()
120 .map(crate::message::MessageKind::as_str)
121 .collect();
122 v.sort_unstable();
123 v
124 }
125
126 #[test]
127 fn the_websocket_connected_row_is_the_standards_own() {
128 assert_eq!(
131 names(None, Cem),
132 alloc::vec![
133 "Handshake",
134 "HandshakeResponse",
135 "ReceptionStatus",
136 "SelectControlType",
137 "SessionRequest",
138 ]
139 );
140 assert_eq!(
141 names(None, Rm),
142 alloc::vec![
143 "Handshake",
144 "PowerForecast",
145 "PowerMeasurement",
146 "ReceptionStatus",
147 "ResourceManagerDetails",
148 "SessionRequest",
149 ]
150 );
151 }
152
153 #[test]
154 fn the_frbc_row_is_the_standards_own() {
155 assert_eq!(
156 names(Some(ControlType::FillRateBasedControl), Cem),
157 alloc::vec![
158 "FRBC.Instruction",
159 "ReceptionStatus",
160 "RevokeObject",
161 "SelectControlType",
162 "SessionRequest",
163 ]
164 );
165 assert_eq!(
166 names(Some(ControlType::FillRateBasedControl), Rm),
167 alloc::vec![
168 "FRBC.ActuatorStatus",
169 "FRBC.FillLevelTargetProfile",
170 "FRBC.LeakageBehaviour",
171 "FRBC.StorageStatus",
172 "FRBC.SystemDescription",
173 "FRBC.TimerStatus",
174 "FRBC.UsageForecast",
175 "InstructionStatusUpdate",
176 "PowerForecast",
177 "PowerMeasurement",
178 "ReceptionStatus",
179 "ResourceManagerDetails",
180 "RevokeObject",
181 "SessionRequest",
182 ]
183 );
184 }
185
186 #[test]
187 fn the_pebc_row_is_the_standards_own() {
188 assert_eq!(
189 names(Some(ControlType::PowerEnvelopeBasedControl), Cem),
190 alloc::vec![
191 "PEBC.Instruction",
192 "ReceptionStatus",
193 "RevokeObject",
194 "SelectControlType",
195 "SessionRequest",
196 ]
197 );
198 assert_eq!(
199 names(Some(ControlType::PowerEnvelopeBasedControl), Rm),
200 alloc::vec![
201 "InstructionStatusUpdate",
202 "PEBC.EnergyConstraint",
203 "PEBC.PowerConstraints",
204 "PowerForecast",
205 "PowerMeasurement",
206 "ReceptionStatus",
207 "ResourceManagerDetails",
208 "RevokeObject",
209 "SessionRequest",
210 ]
211 );
212 }
213
214 #[test]
215 fn selecting_not_controlable_leaves_the_session_where_it_was() {
216 assert_eq!(
219 names(Some(ControlType::NotControllable), Rm),
220 names(None, Rm)
221 );
222 assert_eq!(names(Some(ControlType::NoSelection), Rm), names(None, Rm));
223 }
224
225 #[test]
226 fn a_control_type_message_in_the_wrong_control_type_is_a_state_error() {
227 assert_eq!(
228 allowed(
229 Some(ControlType::PowerEnvelopeBasedControl),
230 Cem,
231 MessageKind::FrbcInstruction
232 ),
233 Allowance::WrongState
234 );
235 assert_eq!(
236 allowed(None, Cem, MessageKind::FrbcInstruction),
237 Allowance::WrongState
238 );
239 }
240
241 #[test]
242 fn a_message_from_the_wrong_role_is_a_role_error() {
243 assert_eq!(
245 allowed(
246 Some(ControlType::FillRateBasedControl),
247 Rm,
248 MessageKind::FrbcInstruction
249 ),
250 Allowance::WrongRole
251 );
252 assert_eq!(
253 allowed(None, Cem, MessageKind::ResourceManagerDetails),
254 Allowance::WrongRole
255 );
256 assert_eq!(
257 allowed(None, Rm, MessageKind::SelectControlType),
258 Allowance::WrongRole
259 );
260 }
261
262 #[test]
263 fn revocation_is_accepted_from_both_roles() {
264 for role in [Cem, Rm] {
268 assert_eq!(
269 allowed(
270 Some(ControlType::FillRateBasedControl),
271 role,
272 MessageKind::RevokeObject
273 ),
274 Allowance::Yes
275 );
276 }
277 }
278
279 #[test]
280 fn instruction_statuses_need_something_to_be_about() {
281 assert_eq!(
282 allowed(None, Rm, MessageKind::InstructionStatusUpdate),
283 Allowance::WrongState
284 );
285 assert_eq!(
286 allowed(
287 Some(ControlType::OperationModeBasedControl),
288 Rm,
289 MessageKind::InstructionStatusUpdate
290 ),
291 Allowance::Yes
292 );
293 }
294
295 #[test]
296 fn every_message_is_allowed_somewhere() {
297 for kind in MessageKind::ALL {
299 let reachable = [
300 None,
301 Some(ControlType::PowerEnvelopeBasedControl),
302 Some(ControlType::PowerProfileBasedControl),
303 Some(ControlType::OperationModeBasedControl),
304 Some(ControlType::FillRateBasedControl),
305 Some(ControlType::DemandDrivenBasedControl),
306 ]
307 .into_iter()
308 .any(|active| {
309 [Cem, Rm]
310 .into_iter()
311 .any(|role| allowed(active, role, *kind).is_allowed())
312 });
313 assert!(reachable, "{kind} can never be sent");
314 }
315 }
316}