jsonerr 0.0.3

jsonerr macro and builder
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
106
107
108
109
110

pub struct JsonErrBuilder {
    meta: Option<serde_json::Value>,
    code: Option<serde_json::Value>,
    message: Option<serde_json::Value>,
    payload: Option<serde_json::Value>,
    origin: Option<Box<dyn std::error::Error>>,
}

impl Default for JsonErrBuilder {
    fn default() -> Self {
        Self::new()
    }
}

impl JsonErrBuilder {
    #[allow(dead_code)]
    pub fn new() -> JsonErrBuilder {
        JsonErrBuilder {
            meta: None,
            code: None,
            message: None,
            payload: None,
            origin: None,
        }
    }

    #[allow(dead_code)]
    pub fn meta(mut self, meta: serde_json::Value) -> JsonErrBuilder {
        self.meta = Some(meta);
        self
    }

    #[allow(dead_code)]
    pub fn code(mut self, code: String) -> JsonErrBuilder {
        self.code = Some(serde_json::json!(code));
        self
    }

    #[allow(dead_code)]
    pub fn message(mut self, message: String) -> JsonErrBuilder {
        self.message = Some(serde_json::json!(message));
        self
    }

    #[allow(dead_code)]
    pub fn payload(mut self, payload: serde_json::Value) -> JsonErrBuilder {
        self.payload = Some(payload);
        self
    }

    #[allow(dead_code)]
    pub fn origin(mut self, error: Box<dyn std::error::Error>) -> JsonErrBuilder {
        self.origin = Some(error);
        self
    }

    /// @TODO = rename to build_json_value
    #[allow(dead_code)]
    pub fn build(self) -> serde_json::Value {
        let mut errorjson = serde_json::json!({
            "iserr" : true,
            "err": {}
        });
        if self.meta.is_some() {
            errorjson["meta"] = self.meta.unwrap();
        }
        if self.code.is_some() {
            errorjson["err"]["code"] = self.code.unwrap();
        }
        if self.message.is_some() {
            errorjson["err"]["message"] = self.message.unwrap();
        }
        if self.payload.is_some() {
            errorjson["err"]["payload"] = self.payload.unwrap();
        }
        if self.origin.is_some() {
            // origin error to string
            let errstring: String = self.origin.unwrap().to_string();
            // try to convert error string (with json stringify) to json value
            let result = serde_json::from_str(&errstring);
            let origin: serde_json::Value;
            // if result.is_ok() {
            if let Ok(result) = result {
                origin = result;
            } else {
                // by defaut 'origin' stay a json 'string'
                origin = serde_json::to_value(&errstring).unwrap();
            }
            errorjson["err"]["origin"] = origin;
        }

        // return
        errorjson
    }

    /// used by wasm
    #[allow(dead_code)]
    pub fn build_string<'a>(self) -> String {
        let result = self.build();
        let result = serde_json::to_string(&result);
        if result.is_err() {
            return format!(
                "whoami=jsonerr:builder, code=ERR0001, message=error serde_json::to_string, origin={}",
                result.unwrap_err(),
            );
        }
        let result_string = result.unwrap();
        return result_string;
    }
}