automapper_validation/generated/fv2510/
utilmd_strom_conditions_fv2510.rs

1// <auto-generated>
2// Generated by automapper-generator generate-conditions
3// AHB: xml-migs-and-ahbs/FV2510/UTILMD_AHB_Strom_2_1_Fehlerkorrektur_20260302.xml
4// Generated: 2026-09-23T08:11:11Z
5// Delegates unchanged conditions to UtilmdStromConditionEvaluatorFV2504 (FV2504).
6// </auto-generated>
7
8#![allow(clippy::style, clippy::complexity)]
9
10#[allow(unused_imports)]
11use crate::eval::format_validators::*;
12use crate::eval::{ConditionEvaluator, ConditionResult, EvaluationContext};
13use crate::generated::fv2504::UtilmdStromConditionEvaluatorFV2504;
14
15/// Condition evaluator for UTILMD_Strom FV2510.
16///
17/// Delegates to [`UtilmdStromConditionEvaluatorFV2504`] for conditions whose AHB description is
18/// unchanged from that version. Local overrides: [2], [3], [20], [28], [29], [79], [136], [139], [157], [158], [168], [169], [242], [253], [258], [263], [297], [312], [313], [326], [328], [346], [413], [414], [415], [416], [461], [534], [557], [560], [561], [562], [564], [565], [578], [681], [686], [2000], [2016], [2121].
19pub struct UtilmdStromConditionEvaluatorFV2510 {
20    fallback: UtilmdStromConditionEvaluatorFV2504,
21}
22
23impl Default for UtilmdStromConditionEvaluatorFV2510 {
24    fn default() -> Self {
25        Self {
26            fallback: UtilmdStromConditionEvaluatorFV2504::default(),
27        }
28    }
29}
30
31/// Condition IDs whose implementation differs from the fallback.
32const FV2510_OVERRIDES: &[u32] = &[
33    2, 3, 20, 28, 29, 79, 136, 139, 157, 158, 168, 169, 242, 253, 258, 263, 297, 312, 313, 326,
34    328, 346, 413, 414, 415, 416, 461, 534, 557, 560, 561, 562, 564, 565, 578, 681, 686, 2000,
35    2016, 2121,
36];
37
38/// Overrides that require context from outside the message.
39const FV2510_EXTERNAL: &[u32] = &[3, 326, 328];
40
41impl ConditionEvaluator for UtilmdStromConditionEvaluatorFV2510 {
42    fn message_type(&self) -> &str {
43        "UTILMD_Strom"
44    }
45
46    fn format_version(&self) -> &str {
47        "FV2510"
48    }
49
50    fn evaluate(&self, condition: u32, ctx: &EvaluationContext) -> ConditionResult {
51        match condition {
52            2 => self.evaluate_2(ctx),
53            3 => self.evaluate_3(ctx),
54            20 => self.evaluate_20(ctx),
55            28 => self.evaluate_28(ctx),
56            29 => self.evaluate_29(ctx),
57            79 => self.evaluate_79(ctx),
58            136 => self.evaluate_136(ctx),
59            139 => self.evaluate_139(ctx),
60            157 => self.evaluate_157(ctx),
61            158 => self.evaluate_158(ctx),
62            168 => self.evaluate_168(ctx),
63            169 => self.evaluate_169(ctx),
64            242 => self.evaluate_242(ctx),
65            253 => self.evaluate_253(ctx),
66            258 => self.evaluate_258(ctx),
67            263 => self.evaluate_263(ctx),
68            297 => self.evaluate_297(ctx),
69            312 => self.evaluate_312(ctx),
70            313 => self.evaluate_313(ctx),
71            326 => self.evaluate_326(ctx),
72            328 => self.evaluate_328(ctx),
73            346 => self.evaluate_346(ctx),
74            413 => self.evaluate_413(ctx),
75            414 => self.evaluate_414(ctx),
76            415 => self.evaluate_415(ctx),
77            416 => self.evaluate_416(ctx),
78            461 => self.evaluate_461(ctx),
79            534 => self.evaluate_534(ctx),
80            557 => self.evaluate_557(ctx),
81            560 => self.evaluate_560(ctx),
82            561 => self.evaluate_561(ctx),
83            562 => self.evaluate_562(ctx),
84            564 => self.evaluate_564(ctx),
85            565 => self.evaluate_565(ctx),
86            578 => self.evaluate_578(ctx),
87            681 => self.evaluate_681(ctx),
88            686 => self.evaluate_686(ctx),
89            2000 => self.evaluate_2000(ctx),
90            2016 => self.evaluate_2016(ctx),
91            2121 => self.evaluate_2121(ctx),
92            other => self.fallback.evaluate(other, ctx),
93        }
94    }
95
96    fn is_external(&self, condition: u32) -> bool {
97        if FV2510_OVERRIDES.contains(&condition) {
98            FV2510_EXTERNAL.contains(&condition)
99        } else {
100            self.fallback.is_external(condition)
101        }
102    }
103
104    fn is_known(&self, condition: u32) -> bool {
105        FV2510_OVERRIDES.contains(&condition) || self.fallback.is_known(condition)
106    }
107}
108
109impl UtilmdStromConditionEvaluatorFV2510 {
110    /// [2] Wenn UNH DE0070 (Übermittlungsfolgenummer) mit 1 vorhanden
111    fn evaluate_2(&self, ctx: &EvaluationContext) -> ConditionResult {
112        ctx.has_segment_matching("UNH", &[(3, 0, "1")])
113    }
114
115    /// [3] Bei Aufteilung, in der Nachricht mit der höchsten Übermittlungsfolgenummer
116    /// EXTERNAL: Requires context from outside the message.
117    fn evaluate_3(&self, ctx: &EvaluationContext) -> ConditionResult {
118        ctx.external.evaluate("is_highest_sequence_in_split")
119    }
120
121    /// [20] Wenn im SG8 SEQ+Z01 (Daten der Marktlokation) mit der gleichen ID im SG8 RFF+Z18 (Referenz auf die ID der Marktlokation) wie in diesem SG8 das SG10 CCI+Z30++Z07 (Verbrauch) vorhanden
122    fn evaluate_20(&self, ctx: &EvaluationContext) -> ConditionResult {
123        let nav = match ctx.navigator() {
124            Some(n) => n,
125            None => return ctx.has_qualified_value("CCI", 0, "Z30", 2, 0, &["Z07"]),
126        };
127        let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
128        for i in 0..sg8_count {
129            let seq_segs = nav.find_segments_in_group("SEQ", &["SG4", "SG8"], i);
130            let has_z01 = seq_segs.iter().any(|s| {
131                s.elements
132                    .first()
133                    .and_then(|e| e.first())
134                    .is_some_and(|v| v == "Z01")
135            });
136            if !has_z01 {
137                continue;
138            }
139            let sg10_count = nav.child_group_instance_count(&["SG4", "SG8"], i, "SG10");
140            for j in 0..sg10_count {
141                let ccis = nav.find_segments_in_child_group("CCI", &["SG4", "SG8"], i, "SG10", j);
142                if ccis.iter().any(|s| {
143                    s.elements
144                        .first()
145                        .and_then(|e| e.first())
146                        .is_some_and(|v| v == "Z30")
147                        && s.elements
148                            .get(2)
149                            .and_then(|e| e.first())
150                            .is_some_and(|v| v == "Z07")
151                }) {
152                    return ConditionResult::True;
153                }
154            }
155        }
156        ConditionResult::False
157    }
158
159    /// [28] Wenn in dieser SG4 IDE+24 das STS+E01++A04: E_0017 bzw. A03: E_0052 (Zusätzlicher Datensatz / ergänzte Marktlokation) nicht vorhanden
160    // REVIEW: Within each SG4 containing IDE+24 (Vorgang), check if STS+E01 with Prüfschritt A04:E_0017 (Zusätzlicher Datensatz) or A03:E_0052 (ergänzte Marktlokation) is absent. Uses navigator to scope the check per SG4 instance. STS elements[0][0]="E01", elements[2][0]=Prüfschritt code, elements[2][1]=codelist. Condition is True when this STS is NOT found in the SG4, indicating no 'additional record' status was set. (medium confidence)
161    fn evaluate_28(&self, ctx: &EvaluationContext) -> ConditionResult {
162        let nav = match ctx.navigator() {
163            Some(n) => n,
164            None => {
165                let sts_segs = ctx.find_segments_with_qualifier("STS", 0, "E01");
166                let found = sts_segs.iter().any(|s| {
167                    let code = s
168                        .elements
169                        .get(2)
170                        .and_then(|e| e.first())
171                        .map(|v| v.as_str());
172                    let list = s.elements.get(2).and_then(|e| e.get(1)).map(|v| v.as_str());
173                    (code == Some("A04") && list == Some("E_0017"))
174                        || (code == Some("A03") && list == Some("E_0052"))
175                });
176                return ConditionResult::from(!found);
177            }
178        };
179        let sg4_count = nav.group_instance_count(&["SG4"]);
180        for i in 0..sg4_count {
181            let ide_segs = nav.find_segments_in_group("IDE", &["SG4"], i);
182            let has_ide_24 = ide_segs.iter().any(|s| {
183                s.elements
184                    .first()
185                    .and_then(|e| e.first())
186                    .is_some_and(|v| v == "24")
187            });
188            if !has_ide_24 {
189                continue;
190            }
191            let sts_segs = nav.find_segments_in_group("STS", &["SG4"], i);
192            let found = sts_segs.iter().any(|s| {
193                let qual = s
194                    .elements
195                    .first()
196                    .and_then(|e| e.first())
197                    .map(|v| v.as_str());
198                let code = s
199                    .elements
200                    .get(2)
201                    .and_then(|e| e.first())
202                    .map(|v| v.as_str());
203                let list = s.elements.get(2).and_then(|e| e.get(1)).map(|v| v.as_str());
204                qual == Some("E01")
205                    && ((code == Some("A04") && list == Some("E_0017"))
206                        || (code == Some("A03") && list == Some("E_0052")))
207            });
208            if !found {
209                return ConditionResult::True;
210            }
211        }
212        ConditionResult::False
213    }
214
215    /// [29] Wenn in dieser SG4 IDE+24 das STS+E01++A06: E_0017 bzw. A05: E_0052 (Zu viele Marktlokationen enthalten / entfallene Marktlokation) nicht vorhanden
216    // REVIEW: Within each SG4 containing IDE+24 (Vorgang), check if STS+E01 with Prüfschritt A06:E_0017 (Zu viele Marktlokationen) or A05:E_0052 (entfallene Marktlokation) is absent. Mirrors condition [28] but for the 'too many / dropped Marktlokation' status codes. True when neither combination is found in the SG4, indicating no 'excess/dropped records' status was set. (medium confidence)
217    fn evaluate_29(&self, ctx: &EvaluationContext) -> ConditionResult {
218        let nav = match ctx.navigator() {
219            Some(n) => n,
220            None => {
221                let sts_segs = ctx.find_segments_with_qualifier("STS", 0, "E01");
222                let found = sts_segs.iter().any(|s| {
223                    let code = s
224                        .elements
225                        .get(2)
226                        .and_then(|e| e.first())
227                        .map(|v| v.as_str());
228                    let list = s.elements.get(2).and_then(|e| e.get(1)).map(|v| v.as_str());
229                    (code == Some("A06") && list == Some("E_0017"))
230                        || (code == Some("A05") && list == Some("E_0052"))
231                });
232                return ConditionResult::from(!found);
233            }
234        };
235        let sg4_count = nav.group_instance_count(&["SG4"]);
236        for i in 0..sg4_count {
237            let ide_segs = nav.find_segments_in_group("IDE", &["SG4"], i);
238            let has_ide_24 = ide_segs.iter().any(|s| {
239                s.elements
240                    .first()
241                    .and_then(|e| e.first())
242                    .is_some_and(|v| v == "24")
243            });
244            if !has_ide_24 {
245                continue;
246            }
247            let sts_segs = nav.find_segments_in_group("STS", &["SG4"], i);
248            let found = sts_segs.iter().any(|s| {
249                let qual = s
250                    .elements
251                    .first()
252                    .and_then(|e| e.first())
253                    .map(|v| v.as_str());
254                let code = s
255                    .elements
256                    .get(2)
257                    .and_then(|e| e.first())
258                    .map(|v| v.as_str());
259                let list = s.elements.get(2).and_then(|e| e.get(1)).map(|v| v.as_str());
260                qual == Some("E01")
261                    && ((code == Some("A06") && list == Some("E_0017"))
262                        || (code == Some("A05") && list == Some("E_0052")))
263            });
264            if !found {
265                return ConditionResult::True;
266            }
267        }
268        ConditionResult::False
269    }
270
271    /// [79] Wenn SG4 STS+7++Z33 (Auszug wegen Stilllegung) vorhanden
272    fn evaluate_79(&self, ctx: &EvaluationContext) -> ConditionResult {
273        // STS+7++Z33: elements[0][0]="7" (Transaktionsgrund), elements[2][0]="Z33" (Auszug wegen Stilllegung).
274        // FV2504's text read STS+7+++Z33 (element 3); since the 2026-03-02 AHB it is element 2, as in [157].
275        ctx.has_segment_matching("STS", &[(0, 0, "7"), (2, 0, "Z33")])
276    }
277
278    /// [136] Wenn SG10 CCI+++E13 (Zählertyp) CAV+EHZ (elektronischer Haushaltszähler) in dieser SG8 vorhanden
279    fn evaluate_136(&self, ctx: &EvaluationContext) -> ConditionResult {
280        let nav = match ctx.navigator() {
281            Some(n) => n,
282            None => return ctx.has_qualified_value("CAV", 0, "EHZ", 0, 0, &["EHZ"]),
283        };
284        let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
285        for i in 0..sg8_count {
286            let sg10_count = nav.child_group_instance_count(&["SG4", "SG8"], i, "SG10");
287            for j in 0..sg10_count {
288                let ccis = nav.find_segments_in_child_group("CCI", &["SG4", "SG8"], i, "SG10", j);
289                let has_cci_e13 = ccis.iter().any(|s| {
290                    s.elements
291                        .get(2)
292                        .and_then(|e| e.first())
293                        .is_some_and(|v| v == "E13")
294                });
295                if has_cci_e13 {
296                    let cavs =
297                        nav.find_segments_in_child_group("CAV", &["SG4", "SG8"], i, "SG10", j);
298                    if cavs.iter().any(|s| {
299                        s.elements
300                            .first()
301                            .and_then(|e| e.first())
302                            .is_some_and(|v| v == "EHZ")
303                    }) {
304                        return ConditionResult::True;
305                    }
306                }
307            }
308        }
309        ConditionResult::False
310    }
311
312    /// [139] Wenn SG10 CAV+IVA (Individuelle Abstimmung) in dieser SG8 nicht vorhanden
313    // REVIEW: True when no SG10 child of any SG8 contains a CAV with elements[0][0]=='IVA'. Iterates all SG8 instances and their SG10 children; returns False as soon as IVA is found, True if absent throughout. 'In dieser SG8' is evaluated message-wide since no specific parent qualifier filter is given. (medium confidence)
314    fn evaluate_139(&self, ctx: &EvaluationContext) -> ConditionResult {
315        let nav = match ctx.navigator() {
316            Some(n) => n,
317            None => return ctx.lacks_qualifier("CAV", 0, "IVA"),
318        };
319        let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
320        for i in 0..sg8_count {
321            let sg10_count = nav.child_group_instance_count(&["SG4", "SG8"], i, "SG10");
322            for j in 0..sg10_count {
323                let cavs = nav.find_segments_in_child_group("CAV", &["SG4", "SG8"], i, "SG10", j);
324                if cavs.iter().any(|s| {
325                    s.elements
326                        .first()
327                        .and_then(|e| e.first())
328                        .is_some_and(|v| v == "IVA")
329                }) {
330                    return ConditionResult::False;
331                }
332            }
333        }
334        ConditionResult::True
335    }
336
337    /// [157] Wenn SG4 STS+7++Z33+ZZB nicht vorhanden
338    fn evaluate_157(&self, ctx: &EvaluationContext) -> ConditionResult {
339        let result = ctx.has_segment_matching("STS", &[(0, 0, "7"), (2, 0, "Z33"), (3, 0, "ZZB")]);
340        match result {
341            ConditionResult::True => ConditionResult::False,
342            ConditionResult::False => ConditionResult::True,
343            ConditionResult::Unknown => ConditionResult::Unknown,
344        }
345    }
346
347    /// [158] Wenn im selben Segment im DE2379 der Code 106 vorhanden ist
348    fn evaluate_158(&self, ctx: &EvaluationContext) -> ConditionResult {
349        ConditionResult::from(ctx.self_segment_value_equals("DTM", 0, 2, "106"))
350    }
351
352    /// [168] Wenn in dieser SG8 im SG8 PIA+Z02 (Gruppenartikel- ID / Artikel-ID), die Artikel-ID 1-02-0-002/ 003/ 004 vorhanden
353    fn evaluate_168(&self, ctx: &EvaluationContext) -> ConditionResult {
354        // HAND-EDITED: "in dieser/derselben SG8" — scoped to the enclosing group.
355        ctx.this_group_has_qualified_value(
356            "PIA",
357            0,
358            "Z02",
359            1,
360            0,
361            &["1-02-0-002", "1-02-0-003", "1-02-0-004"],
362            &["SG4", "SG8"],
363        )
364    }
365
366    /// [169] Wenn zwei SG8 SEQ+Z45 (Netznutzungsabrechnungsdaten der Marktlokation), mit derselben Zeitraum-ID im DE1050, mit Artikel-ID im SG8 PIA+Z02 (Gruppenartikel-ID / Artikel-ID), eine SG8 mit 1-02-0-002 ...
367    // REVIEW: Complex cross-group condition. Collects all SG8 instances having SEQ+Z45 (Netznutzungsabrechnungsdaten), extracting the Zeitraum-ID from SEQ elements[1][0] (DE1050) and the PIA+Z02 article ID from elements[1][0]. Then checks if two such SG8 instances share the same Zeitraum-ID where one has article 1-02-0-002 and the other has 1-02-0-003 or 1-02-0-004. Medium confidence because the article ID string format ('1-02-0-002') must match exactly as stored in the EDIFACT value. (medium confidence)
368    fn evaluate_169(&self, ctx: &EvaluationContext) -> ConditionResult {
369        let nav = match ctx.navigator() {
370            Some(n) => n,
371            None => return ConditionResult::Unknown,
372        };
373        let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
374        let mut sg8_data: Vec<(String, String)> = Vec::new();
375        for i in 0..sg8_count {
376            let seqs = nav.find_segments_in_group("SEQ", &["SG4", "SG8"], i);
377            let zeitraum_id = seqs
378                .iter()
379                .find(|s| {
380                    s.elements
381                        .first()
382                        .and_then(|e| e.first())
383                        .is_some_and(|v| v == "Z45")
384                })
385                .and_then(|s| s.elements.get(1))
386                .and_then(|e| e.first())
387                .filter(|v| !v.is_empty())
388                .cloned();
389            if let Some(zid) = zeitraum_id {
390                let pias = nav.find_segments_in_group("PIA", &["SG4", "SG8"], i);
391                let article_id = pias
392                    .iter()
393                    .find(|s| {
394                        s.elements
395                            .first()
396                            .and_then(|e| e.first())
397                            .is_some_and(|v| v == "Z02")
398                    })
399                    .and_then(|s| s.elements.get(1))
400                    .and_then(|e| e.first())
401                    .cloned()
402                    .unwrap_or_default();
403                sg8_data.push((zid, article_id));
404            }
405        }
406        for i in 0..sg8_data.len() {
407            for j in (i + 1)..sg8_data.len() {
408                if sg8_data[i].0 == sg8_data[j].0 {
409                    let (id_i, id_j) = (&sg8_data[i].1, &sg8_data[j].1);
410                    let i_is_002 = id_i == "1-02-0-002";
411                    let j_is_002 = id_j == "1-02-0-002";
412                    let i_is_003_004 = id_i == "1-02-0-003" || id_i == "1-02-0-004";
413                    let j_is_003_004 = id_j == "1-02-0-003" || id_j == "1-02-0-004";
414                    if (i_is_002 && j_is_003_004) || (j_is_002 && i_is_003_004) {
415                        return ConditionResult::True;
416                    }
417                }
418            }
419        }
420        if sg8_data.is_empty() {
421            ConditionResult::Unknown
422        } else {
423            ConditionResult::False
424        }
425    }
426
427    /// [242] Wenn mehr als ein SG8 (Referenz auf die Lokationsbündelstruktur) mit der selben Zeitraum-ID im DE1050 vorhanden
428    fn evaluate_242(&self, ctx: &EvaluationContext) -> ConditionResult {
429        let nav = match ctx.navigator() {
430            Some(n) => n,
431            None => return ConditionResult::Unknown,
432        };
433        let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
434        let mut ids: Vec<String> = Vec::new();
435        for i in 0..sg8_count {
436            let seq_segs = nav.find_segments_in_group("SEQ", &["SG4", "SG8"], i);
437            for seq in &seq_segs {
438                let qual = seq
439                    .elements
440                    .first()
441                    .and_then(|e| e.first())
442                    .map(|s| s.as_str());
443                if matches!(qual, Some("Z78") | Some("ZC7") | Some("ZC8") | Some("ZD5")) {
444                    if let Some(id) = seq.elements.get(1).and_then(|e| e.first()) {
445                        if !id.is_empty() {
446                            ids.push(id.clone());
447                        }
448                    }
449                }
450            }
451        }
452        if ids.is_empty() {
453            return ConditionResult::Unknown;
454        }
455        let mut seen = std::collections::HashSet::new();
456        ConditionResult::from(ids.iter().any(|id| !seen.insert(id.as_str())))
457    }
458
459    /// [253] Wenn SG4 STS+E01++ZC9 (Ablehnung (keine Zuordnung möglich)) nicht vorhanden
460    fn evaluate_253(&self, ctx: &EvaluationContext) -> ConditionResult {
461        match ctx.has_segment_matching("STS", &[(0, 0, "E01"), (2, 0, "ZC9")]) {
462            ConditionResult::True => ConditionResult::False,
463            ConditionResult::False => ConditionResult::True,
464            ConditionResult::Unknown => ConditionResult::Unknown,
465        }
466    }
467
468    /// [258] Wenn in dieser SG8 SEQ+Z01 (Daten der Marktlokation) SG10 CCI+Z30++Z07 (Verbrauch) vorhanden
469    fn evaluate_258(&self, ctx: &EvaluationContext) -> ConditionResult {
470        // HAND-EDITED: "in dieser SG8 SEQ+Z01 SG10 CCI+Z30++Z07" — the enclosing SG8
471        // only, when the scope reaches one.
472        if let (Some(sg8), Some(nav)) = (ctx.enclosing_scope("SG8"), ctx.navigator()) {
473            let is_z01 = nav
474                .find_segments_in_instance("SEQ", sg8)
475                .iter()
476                .any(|s| s.get_element(0) == "Z01");
477            let verbrauch = nav
478                .find_segments_in_subtree("CCI", sg8)
479                .iter()
480                .any(|s| s.get_element(0) == "Z30" && s.get_component(2, 0) == "Z07");
481            return ConditionResult::from(is_z01 && verbrauch);
482        }
483        let nav = match ctx.navigator() {
484            Some(n) => n,
485            None => return ctx.has_qualified_value("CCI", 0, "Z30", 2, 0, &["Z07"]),
486        };
487        let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
488        for i in 0..sg8_count {
489            let seq_segs = nav.find_segments_in_group("SEQ", &["SG4", "SG8"], i);
490            let has_z01 = seq_segs.iter().any(|s| {
491                s.elements
492                    .first()
493                    .and_then(|e| e.first())
494                    .is_some_and(|v| v == "Z01")
495            });
496            if has_z01 {
497                let sg10_count = nav.child_group_instance_count(&["SG4", "SG8"], i, "SG10");
498                for j in 0..sg10_count {
499                    let ccis =
500                        nav.find_segments_in_child_group("CCI", &["SG4", "SG8"], i, "SG10", j);
501                    if ccis.iter().any(|s| {
502                        s.elements
503                            .first()
504                            .and_then(|e| e.first())
505                            .is_some_and(|v| v == "Z30")
506                            && s.elements
507                                .get(2)
508                                .and_then(|e| e.first())
509                                .is_some_and(|v| v == "Z07")
510                    }) {
511                        return ConditionResult::True;
512                    }
513                }
514            }
515        }
516        ConditionResult::False
517    }
518
519    /// [263] Wenn SG8 SEQ+Z01 (Daten der Marktlokation) SG10 CCI+Z30++Z07 (Verbrauch) vorhanden
520    // Message-wide: any SG8 SEQ+Z01 with an SG10 CCI+Z30++Z07. This is FV2504's [20] text, renumbered.
521    fn evaluate_263(&self, ctx: &EvaluationContext) -> ConditionResult {
522        let nav = match ctx.navigator() {
523            Some(n) => n,
524            None => return ctx.has_qualified_value("CCI", 0, "Z30", 2, 0, &["Z07"]),
525        };
526        let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
527        for i in 0..sg8_count {
528            let seq_segs = nav.find_segments_in_group("SEQ", &["SG4", "SG8"], i);
529            let has_z01 = seq_segs.iter().any(|s| {
530                s.elements
531                    .first()
532                    .and_then(|e| e.first())
533                    .is_some_and(|v| v == "Z01")
534            });
535            if !has_z01 {
536                continue;
537            }
538            let sg10_count = nav.child_group_instance_count(&["SG4", "SG8"], i, "SG10");
539            for j in 0..sg10_count {
540                let ccis = nav.find_segments_in_child_group("CCI", &["SG4", "SG8"], i, "SG10", j);
541                if ccis.iter().any(|s| {
542                    s.elements
543                        .first()
544                        .and_then(|e| e.first())
545                        .is_some_and(|v| v == "Z30")
546                        && s.elements
547                            .get(2)
548                            .and_then(|e| e.first())
549                            .is_some_and(|v| v == "Z07")
550                }) {
551                    return ConditionResult::True;
552                }
553            }
554        }
555        ConditionResult::False
556    }
557
558    /// [297] Wenn mehr als eine SG8 SEQ+Z02/ ZE3 (OBIS- Daten der Marktlokation) mit einer OBIS-Kennzahl für Energiemenge im PIA+5, mit gleicher Zeitraum-ID und identischem Code im DE1229 des SG8 SEQ+Z02/ZA1/Z...
559    // REVIEW: Find SG8 instances with SEQ qualifier Z02 or ZE3 that also have a PIA+5 segment. Collect (de1229_code, zeitraum_id) tuples. Condition is True when more than one such SG8 shares the same combination. Note: 'OBIS-Kennzahl für Energiemenge' filtering is not enforced here (would require knowledge of valid OBIS patterns), so presence of PIA+5 is used as a proxy. (medium confidence)
560    fn evaluate_297(&self, ctx: &EvaluationContext) -> ConditionResult {
561        let nav = match ctx.navigator() {
562            Some(n) => n,
563            None => return ConditionResult::Unknown,
564        };
565        let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
566        // Collect (seq_qualifier, zeitraum_id) tuples from SG8 instances with SEQ+Z02/ZE3 that also have PIA+5
567        let mut keys: Vec<(String, String)> = Vec::new();
568        for i in 0..sg8_count {
569            let seq_segs = nav.find_segments_in_group("SEQ", &["SG4", "SG8"], i);
570            for seq in &seq_segs {
571                let qual = seq
572                    .elements
573                    .first()
574                    .and_then(|e| e.first())
575                    .map(|s| s.as_str());
576                if matches!(qual, Some("Z02") | Some("ZE3")) {
577                    let pia_segs = nav.find_segments_in_group("PIA", &["SG4", "SG8"], i);
578                    let has_pia5 = pia_segs.iter().any(|s| {
579                        s.elements
580                            .first()
581                            .and_then(|e| e.first())
582                            .is_some_and(|v| v == "5")
583                    });
584                    if has_pia5 {
585                        let zeitraum_id = seq
586                            .elements
587                            .get(1)
588                            .and_then(|e| e.first())
589                            .cloned()
590                            .unwrap_or_default();
591                        if !zeitraum_id.is_empty() {
592                            keys.push((qual.unwrap_or_default().to_string(), zeitraum_id));
593                        }
594                    }
595                }
596            }
597        }
598        if keys.is_empty() {
599            return ConditionResult::Unknown;
600        }
601        let mut seen = std::collections::HashSet::new();
602        ConditionResult::from(keys.iter().any(|k| !seen.insert(k)))
603    }
604
605    /// [312] Wenn DTM+137 (Nachrichtendatum) im DE2380 &lt; 202603312200?+00
606    fn evaluate_312(&self, ctx: &EvaluationContext) -> ConditionResult {
607        ctx.dtm_lt("137", "202603312200+00")
608    }
609
610    /// [313] Wenn DTM+137 (Nachrichtendatum) im DE2380 ≥ 202603312200?+00
611    fn evaluate_313(&self, ctx: &EvaluationContext) -> ConditionResult {
612        ctx.dtm_ge("137", "202603312200+00")
613    }
614
615    /// [326] Wenn die Marktlokation nicht stillgelegt wird
616    /// EXTERNAL: Requires context from outside the message.
617    fn evaluate_326(&self, ctx: &EvaluationContext) -> ConditionResult {
618        ctx.external.evaluate("market_location_not_decommissioned")
619    }
620
621    /// [328] Wenn die Marktlokation stillgelegt wird
622    /// EXTERNAL: Requires context from outside the message.
623    fn evaluate_328(&self, ctx: &EvaluationContext) -> ConditionResult {
624        ctx.external.evaluate("market_location_decommissioned")
625    }
626
627    /// [346] Wenn SG10 CCI+++E13 (Zählertyp) CAV+MME (mME) in dieser SG8 vorhanden
628    fn evaluate_346(&self, ctx: &EvaluationContext) -> ConditionResult {
629        let nav = match ctx.navigator() {
630            Some(n) => n,
631            None => {
632                // Fallback: message-wide check for both CCI+E13 and CAV+MME
633                let has_cci = ctx.has_qualifier("CCI", 2, "E13");
634                let has_cav = ctx.has_qualifier("CAV", 0, "MME");
635                return match (has_cci, has_cav) {
636                    (ConditionResult::True, ConditionResult::True) => ConditionResult::True,
637                    (ConditionResult::False, _) | (_, ConditionResult::False) => {
638                        ConditionResult::False
639                    }
640                    _ => ConditionResult::Unknown,
641                };
642            }
643        };
644        let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
645        for i in 0..sg8_count {
646            let sg10_count = nav.child_group_instance_count(&["SG4", "SG8"], i, "SG10");
647            for j in 0..sg10_count {
648                let ccis = nav.find_segments_in_child_group("CCI", &["SG4", "SG8"], i, "SG10", j);
649                let has_cci_e13 = ccis.iter().any(|s| {
650                    s.elements
651                        .get(2)
652                        .and_then(|e| e.first())
653                        .is_some_and(|v| v == "E13")
654                });
655                if has_cci_e13 {
656                    let cavs =
657                        nav.find_segments_in_child_group("CAV", &["SG4", "SG8"], i, "SG10", j);
658                    if cavs.iter().any(|s| {
659                        s.elements
660                            .first()
661                            .and_then(|e| e.first())
662                            .is_some_and(|v| v == "MME")
663                    }) {
664                        return ConditionResult::True;
665                    }
666                }
667            }
668        }
669        ConditionResult::False
670    }
671
672    /// [413] Wenn eine SG8 SEQ+Z02/ZA1/ZA2 (OBIS-Daten der Marktlokation) mit einer OBIS-Kennzahl für Wirkarbeit und kumuliert im PIA+5, mit gleicher Zeitraum-ID und identischem Code im DE1229 des SG8 SEQ+Z02/...
673    fn evaluate_413(&self, ctx: &EvaluationContext) -> ConditionResult {
674        // At least one SG8 SEQ+{Z02|ZA1|ZA2} with matching DE1229 qualifier
675        // and matching DE1050 Zeitraum-ID exists whose PIA+5 OBIS is
676        // Wirkarbeit-kumuliert (C ∈ {1,2}, D ∈ {8,9}).
677        ConditionResult::from(ctx.count_sg8_obis_matches(is_obis_wirkarbeit_kumuliert) >= 1)
678    }
679
680    /// [414] Wenn keine SG8 SEQ+Z02/ZA1/ZA2 (OBIS-Daten der Marktlokation) mit einer OBIS-Kennzahl für Wirkarbeit und kumuliert im PIA+5, mit gleicher Zeitraum-ID und identischem Code im DE1229 des SG8 SEQ+Z02...
681    fn evaluate_414(&self, ctx: &EvaluationContext) -> ConditionResult {
682        // Negation of [413] — no matching kumuliert SG8 exists.
683        ConditionResult::from(ctx.count_sg8_obis_matches(is_obis_wirkarbeit_kumuliert) == 0)
684    }
685
686    /// [415] Wenn eine weitere SG8 SEQ+Z02/ZA1/ZA2 (OBIS-Daten der Marktlokation) mit einer OBIS-Kennzahl für Wirkarbeit und 1/4 Stunde im PIA+5, mit gleicher Zeitraum-ID und identischem Code im DE1229 des SG8...
687    fn evaluate_415(&self, ctx: &EvaluationContext) -> ConditionResult {
688        // "eine weitere" = at least one BESIDES the current → count >= 2.
689        // OBIS predicate: Wirkarbeit 1/4 Stunde (C ∈ {1,2}, D = 29).
690        ConditionResult::from(ctx.count_sg8_obis_matches(is_obis_wirkarbeit_quarter_hour) >= 2)
691    }
692
693    /// [416] Wenn keine SG8 SEQ+Z02/ZA1/ZA2 (OBIS-Daten der Marktlokation) mit einer OBIS-Kennzahl für Wirkarbeit und 1/4 Stunde im PIA+5, mit gleicher Zeitraum-ID und identischem Code im DE1229 des SG8 SEQ+Z0...
694    fn evaluate_416(&self, ctx: &EvaluationContext) -> ConditionResult {
695        // No SG8 matching current's Zeitraum-ID/qualifier has a 1/4 Stunde
696        // Wirkarbeit OBIS in its PIA+5.
697        ConditionResult::from(ctx.count_sg8_obis_matches(is_obis_wirkarbeit_quarter_hour) == 0)
698    }
699
700    /// [461] Wenn in derselben SG10 das CCI (Art und Nutzung der Technischen Ressource) im CAV+ZG8 (Technischen Ressource fällt unter § 14a EnWG) vorhanden
701    fn evaluate_461(&self, ctx: &EvaluationContext) -> ConditionResult {
702        // HAND-EDITED: "in dieser/derselben SG10" — scoped to the enclosing group.
703        // Wenn in derselben SG10 das CCI (Art und Nutzung der Technischen Ressource)
704        // im CAV+ZG8 (Technische Ressource fällt unter § 14a EnWG) vorhanden
705        // CCI is the SG10 entry segment; condition reduces to: any SG10 has CAV with ZG8
706        ctx.this_group_has_qualifier("CAV", 0, "ZG8", &["SG4", "SG8", "SG10"])
707    }
708
709    /// [534] Hinweis: Aufgrund der Wiederholbarkeit des SG4 STS Status der Antwort ist die Angabe von max. acht Verwendungszeiträumen möglich
710    fn evaluate_534(&self, _ctx: &EvaluationContext) -> ConditionResult {
711        // Hinweis: Aufgrund der Wiederholbarkeit des SG4 STS Status der Antwort ist
712        // die Angabe von max. acht Verwendungszeiträumen möglich
713        // — informational note about cardinality, always applies
714        ConditionResult::True
715    }
716
717    /// [557] Hinweis: Wurden vom Verantwortlichen mehr als acht Verwendungszeiträume gesendet, so werden acht beliebige Verwendungszeiträume beantwortet
718    fn evaluate_557(&self, _ctx: &EvaluationContext) -> ConditionResult {
719        // Hinweis: Wurden vom Verantwortlichen mehr als acht Verwendungszeiträume
720        // gesendet, so werden acht beliebige Verwendungszeiträume beantwortet
721        // — informational processing note, always applies
722        ConditionResult::True
723    }
724
725    /// [560] Hinweis: Dies entspricht dem Geschäftsvorfall A
726    fn evaluate_560(&self, _ctx: &EvaluationContext) -> ConditionResult {
727        // Hinweis: Dies entspricht dem Geschäftsvorfall A — informational note, always applies
728        ConditionResult::True
729    }
730
731    /// [561] Hinweis: Dies entspricht dem Geschäftsvorfall B
732    fn evaluate_561(&self, _ctx: &EvaluationContext) -> ConditionResult {
733        // Hinweis: Dies entspricht dem Geschäftsvorfall B — informational note, always applies
734        ConditionResult::True
735    }
736
737    /// [562] Hinweis: Bei Marktlokationen, welche auf Basis von Werten bilanziert werden, wird der erste Tag des Jahres angegeben.
738    fn evaluate_562(&self, _ctx: &EvaluationContext) -> ConditionResult {
739        // Hinweis: Bei Marktlokationen, welche auf Basis von Werten bilanziert werden, wird der erste Tag des Jahres angegeben — informational note, always applies
740        ConditionResult::True
741    }
742
743    /// [564] Hinweis: Das IDE+Z01 (Liste) definiert den Geschäftsvorfall. Alle aufgelisteten IDE+24 sind Bestandteil des Geschäftsvorfalls
744    fn evaluate_564(&self, _ctx: &EvaluationContext) -> ConditionResult {
745        // Hinweis: Das IDE+Z01 (Liste) definiert den Geschäftsvorfall. Alle aufgelisteten IDE+24 sind Bestandteil des Geschäftsvorfalls — informational note, always applies
746        ConditionResult::True
747    }
748
749    /// [565] Hinweis: Das IDE+24 beschreibt einen Bestandteil einer Liste, wenn ein IDE+Z01 vorhanden ist. Es beschreibt nicht den Geschäftsvorfall
750    fn evaluate_565(&self, _ctx: &EvaluationContext) -> ConditionResult {
751        // Hinweis: Das IDE+24 beschreibt einen Bestandteil einer Liste, wenn ein IDE+Z01 vorhanden ist. Es beschreibt nicht den Geschäftsvorfall — informational note, always applies
752        ConditionResult::True
753    }
754
755    /// [578] Hinweis: Dies gilt für den Zeitraum welcher mit Z53 (keine Daten) definiert ist
756    fn evaluate_578(&self, _ctx: &EvaluationContext) -> ConditionResult {
757        // Hinweis: Dies gilt für den Zeitraum welcher mit Z53 (keine Daten) definiert ist — informational note, always applies
758        ConditionResult::True
759    }
760
761    /// [681] Hinweis: Übergangsversorgung gibt es nur bei Marktlokationen, die unter § 38a EnWG fallen. Grundlage ist eine bilaterale Vereinbarung
762    fn evaluate_681(&self, _ctx: &EvaluationContext) -> ConditionResult {
763        // Hinweis: Übergangsversorgung applies only to Marktlokationen under § 38a EnWG based on bilateral agreement — informational note, always applies
764        ConditionResult::True
765    }
766
767    /// [686] Hinweis: Zu verwenden bei der Abmeldung der Übergangsversorgung.
768    fn evaluate_686(&self, _ctx: &EvaluationContext) -> ConditionResult {
769        // Hinweis: Zu verwenden bei der Abmeldung der Übergangsversorgung — informational note, always applies
770        ConditionResult::True
771    }
772
773    /// [2000] Je SG5 LOC+Z16 (Marktlokation) ist genau einmal die Segmentgruppe anzugeben
774    // REVIEW: Checks that per SG4 transaction group, exactly one SG5 child group contains a LOC segment with qualifier Z16 (Marktlokation). Uses parent-child navigator to iterate SG4 instances and count LOC+Z16 occurrences in their SG5 children. Falls back to message-wide count when no navigator is available. (medium confidence)
775    fn evaluate_2000(&self, ctx: &EvaluationContext) -> ConditionResult {
776        // Je SG5 LOC+Z16 (Marktlokation) ist genau einmal die Segmentgruppe anzugeben
777        // Per SG4 transaction group, exactly one SG5 instance should contain LOC+Z16
778        let nav = match ctx.navigator() {
779            Some(n) => n,
780            None => {
781                let count = ctx.count_qualified_in_group("LOC", 0, "Z16", &["SG4", "SG5"]);
782                return ConditionResult::from(count == 1);
783            }
784        };
785        let sg4_count = nav.group_instance_count(&["SG4"]);
786        if sg4_count == 0 {
787            return ConditionResult::Unknown;
788        }
789        for i in 0..sg4_count {
790            let sg5_count = nav.child_group_instance_count(&["SG4"], i, "SG5");
791            let mut loc_z16_count = 0usize;
792            for j in 0..sg5_count {
793                let locs = nav.find_segments_in_child_group("LOC", &["SG4"], i, "SG5", j);
794                for loc in &locs {
795                    if loc
796                        .elements
797                        .first()
798                        .and_then(|e| e.first())
799                        .is_some_and(|v| v == "Z16")
800                    {
801                        loc_z16_count += 1;
802                    }
803                }
804            }
805            if loc_z16_count != 1 {
806                return ConditionResult::False;
807            }
808        }
809        ConditionResult::True
810    }
811
812    /// [2016] Segmentgruppe ist mind. einmal für jede Zeitraum-ID aus dem DE1156 der SG6 RFF+Z49 / Z53 (Verwendungszeitraum der Daten: "Gültige Daten" / "Keine Daten") aus der Anfragennachricht aus SG6 RFF+TN ...
813    // REVIEW: Cross-group Zeitraum-ID correlation: collect DE1156 values from SG6 RFF+Z49/Z53, verify each is covered by at least one SG8 SEQ's DE1050 reference. The mention of 'Anfragenachricht' (request message) and RFF+TN adds ambiguity about whether the source is this message or an external one; implemented as intra-message check on the most direct interpretation. (medium confidence)
814    fn evaluate_2016(&self, ctx: &EvaluationContext) -> ConditionResult {
815        // Segmentgruppe ist mind. einmal für jede Zeitraum-ID aus DE1156 der SG6 RFF+Z49/Z53 anzugeben
816        // Collect Zeitraum-IDs from SG6 RFF+Z49 and Z53 (DE1156 = elements[0][2])
817        // Then verify each required Zeitraum-ID is referenced by at least one SG8 SEQ (DE1050 = elements[1][0])
818        let nav = match ctx.navigator() {
819            Some(n) => n,
820            None => return ConditionResult::Unknown,
821        };
822        let sg6_count = nav.group_instance_count(&["SG4", "SG6"]);
823        let mut required_ids: std::collections::HashSet<String> = std::collections::HashSet::new();
824        for i in 0..sg6_count {
825            let rffs = nav.find_segments_in_group("RFF", &["SG4", "SG6"], i);
826            for rff in &rffs {
827                let qual = rff
828                    .elements
829                    .first()
830                    .and_then(|e| e.first())
831                    .map(|s| s.as_str());
832                if matches!(qual, Some("Z49") | Some("Z53")) {
833                    if let Some(zeitraum_id) = rff.elements.first().and_then(|e| e.get(2)) {
834                        if !zeitraum_id.is_empty() {
835                            required_ids.insert(zeitraum_id.clone());
836                        }
837                    }
838                }
839            }
840        }
841        if required_ids.is_empty() {
842            return ConditionResult::Unknown;
843        }
844        // Check that for each required Zeitraum-ID at least one SG8 SEQ references it via DE1050
845        let sg8_count = nav.group_instance_count(&["SG4", "SG8"]);
846        let mut found_ids: std::collections::HashSet<String> = std::collections::HashSet::new();
847        for i in 0..sg8_count {
848            let seqs = nav.find_segments_in_group("SEQ", &["SG4", "SG8"], i);
849            for seq in &seqs {
850                if let Some(ref_id) = seq.elements.get(1).and_then(|e| e.first()) {
851                    if !ref_id.is_empty() {
852                        found_ids.insert(ref_id.clone());
853                    }
854                }
855            }
856        }
857        ConditionResult::from(required_ids.iter().all(|id| found_ids.contains(id)))
858    }
859
860    /// [2121] Segmentgruppe ist genau einmal je SG8 SEQ+Z01/ Z80/Z81 (Daten der Marktlokation/ Erwartete Daten der Marktlokation/ Im System vorhandene Daten der Marktlokation) anzugeben
861    // REVIEW: Cardinality condition: this segment group must appear exactly once per qualifying SG8 (those with SEQ+Z01/Z80/Z81 — Daten/Erwartete Daten/Im System vorhandene Daten der Marktlokation). As a boolean predicate the condition evaluates True when such qualifying SG8 instances exist, signalling that the subject segment group is required. Full cardinality validation (exactly-once enforcement) requires the broader validator framework. (medium confidence)
862    fn evaluate_2121(&self, ctx: &EvaluationContext) -> ConditionResult {
863        // Segmentgruppe ist genau einmal je SG8 SEQ+Z01/Z80/Z81 anzugeben
864        // True when at least one SG8 with SEQ+Z01, Z80, or Z81 exists (cardinality trigger)
865        ctx.any_group_has_any_qualifier("SEQ", 0, &["Z01", "Z80", "Z81"], &["SG4", "SG8"])
866    }
867}
automapper_validation/generated/fv2510/utilmd_strom_conditions_fv2510.rs

automapper_validation/generated/fv2510/
utilmd_strom_conditions_fv2510.rs
