Struct UnexpectedFields

Source

pub struct UnexpectedFields<'buf>(/* private fields */);

Expand description

A collection of paths that were unexpected according to the schema used while parsing the JSON for an OCPI object.

Implementations§

Source §

impl<'buf> UnexpectedFields<'buf>

Source

pub fn to_strings(&self) -> Vec<String>

Return the field paths as a Vec of Strings.

Source

pub fn into_strings(self) -> Vec<String>

Return the field paths as a Vec of Strings.

Source

pub fn is_empty(&self) -> bool

Return true if the list of unexpected fields is empty.

Examples found in repository ?

examples/lint_tariff.rs (line 15)

6fn main() {
7    const TARIFF_JSON: &str = include_str!("data/tariff_misspelled_field.json");
8
9    let report = tariff::parse_and_report(TARIFF_JSON).unwrap();
10    let guess::Report {
11        unexpected_fields,
12        version,
13    } = report;
14
15    if !unexpected_fields.is_empty() {
16        eprintln!("Strange... there are fields in the tariff that are not defined in the spec.");
17
18        for path in &unexpected_fields {
19            eprintln!("  * {path}");
20        }
21
22        eprintln!();
23    }
24
25    let tariff = version.certain_or(Version::V221);
26    let report = tariff::lint(&tariff);
27
28    print_lint_warnings(&report.warnings);
29}

More examples

Hide additional examples

examples/generate_cdr_from_tariff.rs (line 20)

11fn main() {
12    const TARIFF_JSON: &str = include_str!("data/tariff_time_and_parking_time_separate.json");
13
14    let report = tariff::parse_and_report(TARIFF_JSON).unwrap();
15    let guess::Report {
16        unexpected_fields,
17        version,
18    } = report;
19
20    if !unexpected_fields.is_empty() {
21        eprintln!("Strange... there are fields in the tariff that are not defined in the spec.");
22
23        for path in &unexpected_fields {
24            eprintln!("  * {path}");
25        }
26
27        eprintln!();
28    }
29
30    let tariff = version.certain_or(Version::V221);
31
32    let config = generate::Config {
33        timezone: chrono_tz::Europe::Amsterdam,
34        start_date_time: DateTime::<Utc>::from_str("2025-06-12 18:22:33+00:00").unwrap(),
35        end_date_time: DateTime::<Utc>::from_str("2025-06-12 22:33:44+00:00").unwrap(),
36        max_current_supply_amp: Decimal::from(4),
37        requested_kwh: Decimal::from(24),
38        max_power_supply_kw: Decimal::from(80),
39    };
40    let report = match cdr::generate_from_tariff(&tariff, &config) {
41        Ok(r) => r,
42        Err(set) => {
43            let (error, warnings) = set.into_parts();
44            print_error(&error);
45            print_warnings(&warnings);
46            return;
47        }
48    };
49    let (report, warnings) = report.into_parts();
50
51    print_warnings(&warnings);
52
53    let generate::Report {
54        tariff_id,
55        tariff_currency_code,
56        partial_cdr,
57    } = report;
58
59    println!("CDR genereated for tariff with id: `{tariff_id}` and currency code: `{tariff_currency_code}`");
60    println!("{partial_cdr:#?}");
61}

examples/price_cdr_with_known_version.rs (line 18)

8fn main() {
9    const CDR_JSON: &str = include_str!("data/cdr_time_and_parking_time.json");
10
11    // If you know the version and timezone of a CDR you simply pass them into the `cdr::parse_with_version` fn.
12    let report = cdr::parse_with_version(CDR_JSON, Version::V211).expect("unable to parse CDR");
13    let cdr::ParseReport {
14        cdr,
15        unexpected_fields,
16    } = report;
17
18    if !unexpected_fields.is_empty() {
19        eprintln!("Strange... there are fields in the CDR that are not defined in the spec.");
20
21        for path in &unexpected_fields {
22            eprintln!("{path}");
23        }
24    }
25
26    let report = match cdr::price(&cdr, price::TariffSource::UseCdr, Tz::Europe__Amsterdam) {
27        Ok(r) => r,
28        Err(set) => {
29            let (error, warnings) = set.into_parts();
30            print_pricing_error(&error);
31            print_pricing_warnings(&warnings);
32            return;
33        }
34    };
35
36    let (report, warnings) = report.into_parts();
37    print_pricing_warnings(&warnings);
38
39    // The various fields of the `price::Report` can be examined or converted to JSON.
40    let price::Report {
41        periods: _,
42        tariff_used: _,
43        tariff_reports: _,
44        timezone: _,
45        billed_energy: _,
46        billed_parking_time: _,
47        total_charging_time: _,
48        billed_charging_time: _,
49        total_cost: _,
50        total_fixed_cost: _,
51        total_time: _,
52        total_time_cost: _,
53        total_energy: _,
54        total_energy_cost: _,
55        total_parking_time: _,
56        total_parking_cost: _,
57        total_reservation_cost: _,
58    } = report;
59}

examples/price_cdr_with_unknown_version.rs (line 44)

6fn main() {
7    const CDR_JSON: &str = include_str!("data/cdr_time_and_parking_time.json");
8
9    // First the raw JSON should be parsed into a `cdr::Versioned` object.
10    // The `cdr::Report` returned from calling `cdr::parse` contains a `cdr::Versioned` object
11    // and a potential list of unexpected fields based on the OCPI v221 spec.
12    let cdr = cdr::parse(CDR_JSON).expect("Unable to parse CDR JSON");
13
14    // The guessed Version can be either certain or uncertain.
15    // In this case we discard the CDR object and try to convert it into a version.
16    // If the version is uncertain then fallback to presuming the CDR is v211.
17    let cdr = cdr.certain_or(Version::V211);
18
19    // The timezone can be inferred or found in the CDR, but a versioned CDR is required.
20    let timezone = match timezone::find_or_infer(&cdr) {
21        Ok(tz) => tz,
22        Err(err_set) => {
23            let (error, warnings) = err_set.into_parts();
24            eprintln!("Unable to infer timezone");
25            print_timezone_error(&error);
26            print_timezone_warnings(&warnings);
27            return;
28        }
29    };
30    let (timezone_source, warnings) = timezone.into_parts();
31
32    if !warnings.is_empty() {
33        print_timezone_warnings(&warnings);
34    }
35
36    // We don't care whether the timezone was found or inferred.
37    let timezone = timezone_source.into_timezone();
38    let report = cdr::parse_with_version(CDR_JSON, Version::V211).expect("Unable to parse CDR");
39    let cdr::ParseReport {
40        cdr,
41        unexpected_fields,
42    } = report;
43
44    if !unexpected_fields.is_empty() {
45        eprintln!("Strange... there are fields in the CDR that are not defined in the spec.");
46
47        for path in &unexpected_fields {
48            eprintln!("{path}");
49        }
50    }
51
52    let report = match cdr::price(&cdr, price::TariffSource::UseCdr, timezone) {
53        Ok(r) => r,
54        Err(set) => {
55            let (error, warnings) = set.into_parts();
56            print_pricing_error(&error);
57            print_pricing_warnings(&warnings);
58            return;
59        }
60    };
61
62    let (report, warnings) = report.into_parts();
63
64    print_pricing_warnings(&warnings);
65
66    // The various fields of the `price::Report` can be examined or converted to JSON.
67    let price::Report {
68        periods: _,
69        tariff_used: _,
70        tariff_reports: _,
71        timezone: _,
72        billed_energy: _,
73        billed_parking_time: _,
74        total_charging_time: _,
75        billed_charging_time: _,
76        total_cost: _,
77        total_fixed_cost: _,
78        total_time: _,
79        total_time_cost: _,
80        total_energy: _,
81        total_energy_cost: _,
82        total_parking_time: _,
83        total_parking_cost: _,
84        total_reservation_cost: _,
85    } = report;
86}