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 16)

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

More examples

Hide additional examples

examples/generate_cdr_from_tariff.rs (line 22)

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

examples/price_cdr_with_known_version.rs (line 19)

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

examples/price_cdr_with_unknown_version.rs (line 45)

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