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

use super::input_request::*;
use cyfs_base::*;

use serde_json::{Map, Value};

impl JsonCodec<CryptoInputRequestCommon> for CryptoInputRequestCommon {
    fn encode_json(&self) -> Map<String, Value> {
        let mut obj = Map::new();

        JsonCodecHelper::encode_option_string_field(&mut obj, "req_path", self.req_path.as_ref());
        JsonCodecHelper::encode_option_string_field(&mut obj, "dec_id", self.dec_id.as_ref());
        JsonCodecHelper::encode_string_field(&mut obj, "source", &self.source);
        JsonCodecHelper::encode_string_field(&mut obj, "protocol", &self.protocol);
        JsonCodecHelper::encode_option_string_field(&mut obj, "target", self.target.as_ref());
        JsonCodecHelper::encode_number_field(&mut obj, "flags", self.flags);

        obj
    }

    fn decode_json(obj: &Map<String, Value>) -> BuckyResult<CryptoInputRequestCommon> {
        Ok(Self {
            req_path: JsonCodecHelper::decode_option_string_field(obj, "req_path")?,
            dec_id: JsonCodecHelper::decode_option_string_field(obj, "dec_id")?,

            source: JsonCodecHelper::decode_string_field(obj, "source")?,
            protocol: JsonCodecHelper::decode_string_field(obj, "protocol")?,

            target: JsonCodecHelper::decode_option_string_field(obj, "target")?,
            flags: JsonCodecHelper::decode_int_field(obj, "flags")?,
        })
    }
}

// sign_object
impl JsonCodec<CryptoSignObjectInputRequest> for CryptoSignObjectInputRequest {
    fn encode_json(&self) -> Map<String, Value> {
        let mut obj = Map::new();

        JsonCodecHelper::encode_field(&mut obj, "common", &self.common);
        JsonCodecHelper::encode_field(&mut obj, "object", &self.object);
        JsonCodecHelper::encode_number_field(&mut obj, "flags", self.flags);

        obj
    }

    fn decode_json(obj: &Map<String, Value>) -> BuckyResult<CryptoSignObjectInputRequest> {
        Ok(Self {
            common: JsonCodecHelper::decode_field(obj, "common")?,
            object: JsonCodecHelper::decode_field(obj, "object")?,
            flags: JsonCodecHelper::decode_int_field(obj, "flags")?,
        })
    }
}

impl JsonCodec<CryptoSignObjectInputResponse> for CryptoSignObjectInputResponse {
    fn encode_json(&self) -> Map<String, Value> {
        let mut obj = Map::new();

        JsonCodecHelper::encode_string_field(&mut obj, "result", &self.result);
        JsonCodecHelper::encode_option_field(&mut obj, "object", self.object.as_ref());

        obj
    }

    fn decode_json(obj: &Map<String, Value>) -> BuckyResult<CryptoSignObjectInputResponse> {
        Ok(Self {
            result: JsonCodecHelper::decode_string_field(obj, "result")?,
            object: JsonCodecHelper::decode_option_field(obj, "object")?,
        })
    }
}

// verify_object
impl JsonCodec<CryptoVerifyObjectInputRequest> for CryptoVerifyObjectInputRequest {
    fn encode_json(&self) -> Map<String, Value> {
        let mut obj = Map::new();

        JsonCodecHelper::encode_field(&mut obj, "common", &self.common);

        JsonCodecHelper::encode_string_field(&mut obj, "sign_type", &self.sign_type);

        JsonCodecHelper::encode_field(&mut obj, "object", &self.object);

        JsonCodecHelper::encode_field(&mut obj, "sign_object", &self.sign_object);

        obj
    }

    fn decode_json(obj: &Map<String, Value>) -> BuckyResult<CryptoVerifyObjectInputRequest> {
       
        Ok(Self {
            common: JsonCodecHelper::decode_field(obj, "common")?,
            sign_type: JsonCodecHelper::decode_string_field(obj, "sign_type")?,
            object: JsonCodecHelper::decode_field(obj, "object")?,
            sign_object: JsonCodecHelper::decode_field(obj, "sign_object")?,
        })
    }
}