v_individual_model/onto/
individual2json.rs

1use crate::onto::datatype::{exponent_to_scale, DataType, Lang};
2use crate::onto::individual::IndividualObj;
3use crate::onto::resource::{Resource, Value};
4use base64::{Engine as _, engine::general_purpose};
5use chrono::{TimeZone, Utc};
6use rust_decimal::Decimal;
7use serde::ser::{Serialize, SerializeMap, SerializeStruct, Serializer};
8use serde_json::json;
9use serde_json::value::Value as JSONValue;
10
11impl IndividualObj {
12    pub fn as_json_str(&self) -> String {
13        if let Ok(b) = serde_json::to_value(self) {
14            return b.to_string();
15        }
16        "".to_owned()
17    }
18
19    pub fn as_json(&self) -> JSONValue {
20        if let Ok(b) = serde_json::to_value(self) {
21            return b;
22        }
23
24        json!(null)
25    }
26}
27
28impl Serialize for IndividualObj {
29    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
30    where
31        S: Serializer,
32    {
33        let mut map = serializer.serialize_map(Some(self.resources.len()))?;
34        map.serialize_entry("@", &self.uri)?;
35        for (k, v) in &self.resources {
36            map.serialize_entry(&k, &v)?;
37        }
38        map.end()
39    }
40}
41
42impl Serialize for Resource {
43    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
44    where
45        S: Serializer,
46    {
47        let mut tup = serializer.serialize_struct("E", 0)?;
48
49        match &self.value {
50            Value::Num(_m, _e) => {
51                tup.serialize_field("data", &self.value)?;
52            },
53            Value::Int(i) => {
54                tup.serialize_field("data", i)?;
55            },
56            Value::Datetime(i) => {
57                let dt = *i;
58                if let Some(datetime) = Utc.timestamp_opt(dt, 0).single() {
59                    tup.serialize_field("data", &format!("{:?}", datetime))?;
60                } else {
61                    error!("Invalid timestamp value: {}", dt);
62                    tup.serialize_field("data", &format!("Invalid timestamp: {}", dt))?;
63                }
64            },
65            Value::Bool(b) => {
66                tup.serialize_field("data", b)?;
67            },
68            Value::Str(s, l) => {
69                tup.serialize_field("data", s)?;
70
71                if self.rtype == DataType::String && l.is_some() {
72                    tup.serialize_field("lang", l)?;
73                }
74            },
75            Value::Uri(s) => {
76                tup.serialize_field("data", s)?;
77            },
78            Value::Binary(bytes) => {
79                let base64_str = general_purpose::STANDARD.encode(bytes);
80                tup.serialize_field("data", &base64_str)?;
81            },
82        }
83        tup.serialize_field("type", &self.rtype)?;
84
85        tup.end()
86    }
87}
88
89impl Serialize for Value {
90    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
91    where
92        S: Serializer,
93    {
94        match &self {
95            Value::Num(m, e) => {
96                let (num, scale) = exponent_to_scale(m, e);
97                let d = Decimal::new(num, scale);
98                serializer.serialize_str(&d.to_string())
99            },
100            Value::Int(i) => serializer.serialize_i64(*i),
101            Value::Datetime(i) => serializer.serialize_i64(*i),
102            Value::Bool(b) => serializer.serialize_bool(*b),
103            Value::Str(s, l) => {
104                //serializer.serialize_newtype_variant("type", 0, "data", s)
105
106                let mut tup = serializer.serialize_struct("E", 0)?;
107                //tup.serialize_element(&*s)?;
108                tup.serialize_field("data", s)?;
109
110                if l.is_some() {
111                    tup.serialize_field("lang", l)?;
112                }
113                tup.end()
114            },
115            Value::Uri(s) => {
116                //serializer.serialize_newtype_variant("type", 0, "data", s)
117
118                let mut tup = serializer.serialize_struct("E", 0)?;
119                //tup.serialize_element(&*s)?;
120                tup.serialize_field("data", s)?;
121
122                tup.end()
123            },
124            Value::Binary(bytes) => {
125                let base64_str = general_purpose::STANDARD.encode(bytes);
126                serializer.serialize_str(&base64_str)
127            },
128        }
129    }
130}
131
132impl Serialize for Lang {
133    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
134    where
135        S: Serializer,
136    {
137        serializer.serialize_str(self.to_string())
138    }
139}
140
141impl Serialize for DataType {
142    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
143    where
144        S: Serializer,
145    {
146        match &self {
147            DataType::Uri => serializer.serialize_str("Uri"),
148            DataType::String => serializer.serialize_str("String"),
149            DataType::Integer => serializer.serialize_str("Integer"),
150            DataType::Datetime => serializer.serialize_str("Datetime"),
151            DataType::Decimal => serializer.serialize_str("Decimal"),
152            DataType::Boolean => serializer.serialize_str("Boolean"),
153            DataType::Binary => serializer.serialize_str("Binary"),
154        }
155    }
156}
v_individual_model/onto/individual2json.rs

v_individual_model/onto/
individual2json.rs
