Crate ocpi_tariffs 

OCPI Tariffs library

Calculate the (sub)totals of a charge session using the cdr::price function and use the generated price::Report to review and compare the calculated totals versus the sources from the CDR.

• Use json::parse_object to parse a CDR or tariff &str into a json::Document.
• Use cdr::infer_version or tariff::infer_version to guess which OCPI Version a CDR or tariff is.
• Use the cdr::build and tariff::build functions to check a json::Document against the schema for a given version.
• Use the tariff::lint to lint a tariff: flag common errors, bugs, dangerous constructs and stylistic flaws in the tariff.

Examples

Price a CDR with embedded tariff

If you have a CDR JSON with an embedded tariff you can price the CDR with the following code:

let doc = json::parse_object(CDR_JSON)?;
let (cdr, _warnings) = cdr::build(doc, Version::V211).into_parts();

let report = cdr::price(&cdr, price::TariffSource::UseCdr, chrono_tz::Tz::Europe__Amsterdam).unwrap();
let (report, warnings) = report.into_parts();

if !warnings.is_empty() {
    eprintln!("Pricing the CDR resulted in `{}` warnings", warnings.len_warnings());

    for group in warnings {
        let (element, warnings) = group.to_parts();
        eprintln!("  {}", element.path);

        for warning in warnings {
            eprintln!("    - {warning}");
        }
    }
}

Price a CDR using tariff in separate JSON file

If you have a CDR JSON with a tariff in a separate JSON file you can price the CDR with the following code:

let cdr_doc = json::parse_object(CDR_JSON)?;
let (cdr, _cdr_warnings) = cdr::build(cdr_doc, Version::V211).into_parts();

let tariff_doc = json::parse_object(TARIFF_JSON)?;
let (tariff, _tariff_warnings) = tariff::build(tariff_doc, Version::V211).into_parts();

let report = cdr::price(&cdr, price::TariffSource::Override(vec![tariff]), chrono_tz::Tz::Europe__Amsterdam).unwrap();
let (report, warnings) = report.into_parts();

if !warnings.is_empty() {
    eprintln!("Pricing the CDR resulted in `{}` warnings", warnings.len_warnings());

    for group in warnings {
        let (element, warnings) = group.to_parts();
        eprintln!("  {}", element.path);

        for warning in warnings {
            eprintln!("    - {warning}");
        }
    }
}

Lint a tariff

let doc = json::parse_object(TARIFF_JSON)?;
let guess::Version::Certain(tariff) = tariff::infer_version(doc) else {
    return Err("Unable to guess the version of given tariff JSON.".into());
};
let tariff = tariff::build_versioned(tariff).ignore_warnings();

let report = tariff::lint(&tariff);

eprintln!("`{}` lint warnings found", report.warnings.len_warnings());

for group in report.warnings {
    let (element, warnings) = group.to_parts();
    eprintln!(
        "Warnings reported for `json::Element` at path: `{}`",
        element.path
    );

    for warning in warnings {
        eprintln!("  * {warning}");
    }

    eprintln!();
}

Modules

cdr

Parse a CDR and price the result with a tariff.

country

An ISO 3166-1 country code.

currency

An ISO 4217 currency code.

datetime

Timestamps are formatted as a string with a max length of 25 chars. Each timestamp follows RFC 3339, with some additional limitations. All timestamps are expected to be in UTC. The absence of the timezone designator implies a UTC timestamp. Fractional seconds may be used.

duration

The OCPI spec represents some durations as fractional hours, where this crate represents all durations using TimeDelta. The ToDuration and ToHoursDecimal traits can be used to convert a TimeDelta into a Decimal and vice versa.

enumeration

Types to parse all OCPI enumerations.

explain

Explain an OCPI object in human language.

generate

Generate a CDR from a tariff.

guess

Guess the Version of the given CDR or tariff.

json

JSON parsing and typed decoding for the OCPI CDR pricing/generating and CDR/Tariff linting pipeline.

lint

Both tariffs and CDRs can be linted - a term borrowed from software development where linting is the act of flagging common errors, bugs, dangerous constructs and stylistic flaws in a some code or data.

money

Various monetary types.

number

We represent the OCPI spec Number as a Decimal and serialize and deserialize to the precision defined in the OCPI spec.

price

Price a CDR using a tariff and compare the prices embedded in the CDR with the prices computed here.

schema

string

Case Insensitive String. Only printable ASCII allowed.

tariff

Parse a tariff and lint the result.

timezone

Parse an IANA Timezone from JSON or find a timezone in a CDR.

warning

These types are the basis for writing functions that can emit a set of Warnings based on the value they are trying to create.

weekday

The Warning infrastructure for the OCPI DayOfWeek type.

Macros

define_enum_from_json

This macro defines the FromJson impl for the given enum.

Structs

Ampere

A value of amperes.

Caveat

A value that may have associated Warnings.

Kw

A value of kilo watts.

Kwh

A value of kilo watt hours.

Money

A monetary amount, the currency is dependent on the specified tariff.

Price

A price consisting of a value including VAT, and a value excluding VAT.

Vat

A VAT percentage.

Enums

Version

The OCPI versions supported by this crate.

Traits

Cost

An item that has a cost.

ToDuration

Convert a Decimal amount of hours to a TimeDelta.

ToHoursDecimal

Convert a TimeDelta into a Decimal based amount of hours.

Unversioned

An object with an uncertain Version.

VerdictExt

Verdict specific extension methods for the Result type.

Versioned

An object for a specific OCPI Version.

Warning

Each mod defines warnings for the type that it’s trying to parse or lint from a json::Element.

Type Aliases

TariffId

The Id for a tariff used in the pricing of a CDR.

Verdict

A Verdict is a standard Result with Warnings potentially issued for both the Ok and Err variants.