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

use crate::*;
use cyfs_base::*;

use serde_json::{Map, Value};
use std::fmt;

// 用以bdt层的权限控制交换信息
pub struct BdtDataRefererInfo {
    // refer target: maybe owner of object; or dsg contract etc.
    pub target: Option<ObjectId>, 
    pub object_id: ObjectId,
    pub inner_path: Option<String>,

    // source-dec-id
    pub dec_id: Option<ObjectId>,

    // target-dec-id and req-path, etc
    pub req_path: Option<String>,
    
    pub referer_object: Vec<NDNDataRefererObject>,
    pub flags: u32,
}

impl fmt::Display for BdtDataRefererInfo {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        if let Some(target) = &self.target {
            write!(f, ", target: {}", target)?;
        }
        write!(f, "object_id: {:?}", self.object_id)?;
        if let Some(inner_path) = &self.inner_path {
            write!(f, ", inner_path: {}", inner_path)?;
        }

        if let Some(dec_id) = &self.dec_id {
            write!(f, ", dec_id: {}", dec_id)?;
        }
        
        write!(f, ", req_path: {:?}", self.req_path)?;
        if !self.referer_object.is_empty() {
            write!(f, ", referer_object: {:?}", self.referer_object)?;
        }

        write!(f, ", flags: {}", self.flags)?;

        Ok(())
    }
}

impl fmt::Debug for BdtDataRefererInfo {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt::Display::fmt(&self, f)
    }
}

impl JsonCodec<BdtDataRefererInfo> for BdtDataRefererInfo {
    fn encode_json(&self) -> Map<String, Value> {
        let mut obj = Map::new();
        JsonCodecHelper::encode_option_string_field(&mut obj, "target", self.target.as_ref());
        JsonCodecHelper::encode_string_field(&mut obj, "object_id", &self.object_id);
        JsonCodecHelper::encode_option_string_field(&mut obj, "inner_path", self.inner_path.as_ref());

        JsonCodecHelper::encode_option_string_field(&mut obj, "dec_id", self.dec_id.as_ref());
        JsonCodecHelper::encode_option_string_field(&mut obj, "req_path", self.req_path.as_ref());

        if self.referer_object.len() > 0 {
            JsonCodecHelper::encode_str_array_field(
                &mut obj,
                "referer_object",
                &self.referer_object,
            );
        }

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

        obj
    }

    fn decode_json(obj: &Map<String, Value>) -> BuckyResult<BdtDataRefererInfo> {
        Ok(Self {
            target: JsonCodecHelper::decode_option_string_field(obj,"target")?,
            object_id: JsonCodecHelper::decode_string_field(obj,"object_id")?,
            inner_path: JsonCodecHelper::decode_option_string_field(obj,"inner_path")?,
            dec_id: JsonCodecHelper::decode_option_string_field(obj, "dec_id")?,
            req_path: JsonCodecHelper::decode_option_string_field(obj, "req_path")?,
            referer_object: JsonCodecHelper::decode_str_array_field(obj, "referer_object")?,
            flags: JsonCodecHelper::decode_int_field(obj, "flags")?,
        })
    }
}


impl From<&NDNGetDataInputRequest> for  BdtDataRefererInfo{
    fn from(req: &NDNGetDataInputRequest) -> Self {
        BdtDataRefererInfo {
            // FIXME: set target field from o link
            target: None, 
            object_id: req.object_id.clone(),
            inner_path: req.inner_path.clone(),
            dec_id: req.common.source.get_opt_dec().cloned(),
            req_path: req.common.req_path.clone(),
            referer_object: req.common.referer_object.clone(),
            flags: req.common.flags,
        }
    }
}