v_common_onto/
individual2json.rs

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

v_common_onto/
individual2json.rs
