ocpp_rs 0.4.0

no_std + alloc OCPP 1.6 and 2.1 protocol library (OCPP-J parse/serialize, CallResult correlation).
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

//! Shared datetime wire helpers for OCPP 1.6 and 2.1.
//!
//! **Parse** always uses RFC3339 (accepts `%.3fZ`, offsets, variable fractional seconds, etc.).
//! **Serialize** defaults to strict `%Y-%m-%dT%H:%M:%S%.3fZ`; enable
//! `datetime_serialize_rfc3339` to emit `to_rfc3339_opts(Millis, true)` instead.

use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};

/// UTC datetime wrapper used by OCPP payload fields.
#[derive(Debug, Eq, PartialEq, Serialize, Deserialize, Clone, Default, Copy)]
pub struct DateTimeWrapper(DateTime<Utc>);

impl DateTimeWrapper {
    #[must_use]
    pub const fn new(dt: DateTime<Utc>) -> Self {
        Self(dt)
    }

    #[must_use]
    pub const fn inner(&self) -> DateTime<Utc> {
        self.0
    }
}

const STRICT_FORMAT: &str = "%Y-%m-%dT%H:%M:%S%.3fZ";

fn serialize_utc<S>(dt: DateTime<Utc>, serializer: S) -> Result<S::Ok, S::Error>
where
    S: serde::Serializer,
{
    #[cfg(feature = "datetime_serialize_rfc3339")]
    {
        use chrono::SecondsFormat;
        let s = dt.to_rfc3339_opts(SecondsFormat::Millis, true);
        serializer.serialize_str(&s)
    }
    #[cfg(not(feature = "datetime_serialize_rfc3339"))]
    {
        use alloc::format;
        let s = format!("{}", dt.format(STRICT_FORMAT));
        serializer.serialize_str(&s)
    }
}

fn parse_utc(s: &str) -> Result<DateTime<Utc>, alloc::string::String> {
    DateTime::parse_from_rfc3339(s)
        .map(|dt| dt.with_timezone(&Utc))
        .map_err(|e| alloc::format!("{e}"))
}

/// Serde helpers for required [`DateTimeWrapper`] fields.
pub mod date_time {
    use super::{DateTimeWrapper, parse_utc, serialize_utc};
    use alloc::string::String;
    use serde::{self, Deserialize, Deserializer, Serializer};

    pub fn serialize<S>(date: &DateTimeWrapper, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        serialize_utc(date.inner(), serializer)
    }

    pub fn deserialize<'de, D>(deserializer: D) -> Result<DateTimeWrapper, D::Error>
    where
        D: Deserializer<'de>,
    {
        let s = String::deserialize(deserializer)?;
        parse_utc(&s)
            .map(DateTimeWrapper::new)
            .map_err(serde::de::Error::custom)
    }
}

/// Serde helpers for optional [`DateTimeWrapper`] fields.
pub mod date_time_optional {
    use super::{DateTimeWrapper, parse_utc, serialize_utc};
    use alloc::string::String;
    use serde::{self, Deserialize, Deserializer, Serializer};

    #[allow(clippy::ref_option)]
    pub fn serialize<S>(date: &Option<DateTimeWrapper>, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        match date {
            Some(date) => serialize_utc(date.inner(), serializer),
            None => serializer.serialize_none(),
        }
    }

    pub fn deserialize<'de, D>(deserializer: D) -> Result<Option<DateTimeWrapper>, D::Error>
    where
        D: Deserializer<'de>,
    {
        let opt: Option<String> = Option::deserialize(deserializer)?;
        match opt {
            Some(s) => parse_utc(&s)
                .map(|dt| Some(DateTimeWrapper::new(dt)))
                .map_err(serde::de::Error::custom),
            None => Ok(None),
        }
    }
}