cyfs_base/codec/
format.rs

1use crate::*;
2
3use serde::Serialize;
4use serde_json::{Map, Value};
5
6pub trait ObjectFormat {
7    fn format_json(&self) -> serde_json::Value;
8}
9
10// auto impl ObjectFormat for struct which use Serialize macros + ObjectFormatAutoWithSerde
11impl<T> ObjectFormat for T
12where
13    T: Serialize + ObjectFormatAutoWithSerde,
14{
15    fn format_json(&self) -> serde_json::Value {
16        serde_json::to_value(self).unwrap()
17    }
18}
19
20pub trait ObjectFormatAutoWithSerde {}
21
22#[macro_export]
23macro_rules! object_format_empty_impl {
24    ($content:ty) => {
25        impl ObjectFormat for $content {
26            fn format_json(&self) -> serde_json::Value {
27                serde_json::Map::new().into()
28            }
29        }
30    };
31}
32
33#[macro_export]
34macro_rules! object_format_not_impl {
35    ($content:ty) => {
36        impl ObjectFormat for $content {
37            fn format_json(&self) -> serde_json::Value {
38                serde_json::Value::String("[unimplemented]".to_owned())
39            }
40        }
41    };
42}
43
44pub struct ObjectFormatHelper;
45
46impl ObjectFormatHelper {
47    pub fn encode_field<T: ?Sized>(obj: &mut Map<String, Value>, key: impl ToString, value: &T)
48    where
49        T: ObjectFormat,
50    {
51        obj.insert(key.to_string(), value.format_json());
52    }
53
54    pub fn encode_option_field<T>(
55        obj: &mut Map<String, Value>,
56        key: impl ToString,
57        value: Option<&T>,
58    ) where
59        T: ObjectFormat,
60    {
61        if let Some(value) = value {
62            obj.insert(key.to_string(), value.format_json());
63        }
64    }
65
66    pub fn encode_array<'a, T: 'a, I: IntoIterator<Item = &'a T>>(
67        obj: &mut Map<String, Value>,
68        key: impl ToString,
69        it: I,
70    ) where
71        T: ObjectFormat,
72    {
73        obj.insert(key.to_string(), Self::encode_to_array(it));
74    }
75
76    pub fn encode_to_array<'a, T: 'a, I: IntoIterator<Item = &'a T>>(it: I) -> Value
77    where
78        T: ObjectFormat,
79    {
80        let mut result = Vec::new();
81        for item in it.into_iter() {
82            let item = T::format_json(item);
83            result.push(item);
84        }
85
86        Value::Array(result)
87    }
88
89    pub fn format_time(time: u64) -> String {
90        use chrono::{DateTime, Utc};
91
92        if time > 0 {
93            let st = bucky_time_to_system_time(time);
94
95            let now: DateTime<Utc> = st.into();
96            let now = now.to_rfc3339();
97            format!("{},{}", now, time)
98        } else {
99            "0".to_owned()
100        }
101    }
102}
103
104impl<T> ObjectFormat for NamedObjectDesc<T>
105where
106    T: DescContent + ObjectFormat,
107    T::OwnerType: OwnerObj,
108    T::AreaType: AreaObj,
109    T::AuthorType: AuthorObj,
110    T::PublicKeyType: PublicKeyObj,
111    NamedObjectDesc<T>:
112        ObjectDesc + OwnerObjectDesc + AreaObjectDesc + AuthorObjectDesc + PublicKeyObjectDesc,
113{
114    fn format_json(&self) -> serde_json::Value {
115        let mut map = serde_json::Map::new();
116
117        let t = self.obj_type();
118        JsonCodecHelper::encode_number_field(&mut map, "object_type", t);
119
120        let object_id = self.calculate_id();
121        JsonCodecHelper::encode_string_field(&mut map, "object_id", &object_id);
122
123        JsonCodecHelper::encode_string_field(
124            &mut map,
125            "object_category",
126            &object_id.object_category(),
127        );
128
129        JsonCodecHelper::encode_string_field_2(
130            &mut map,
131            "object_type_code",
132            format!("{:?}", object_id.obj_type_code()),
133        );
134
135        if let Some(dec_id) = self.dec_id() {
136            JsonCodecHelper::encode_string_field(&mut map, "dec_id", dec_id);
137        }
138
139        if let Some(ref_objs) = self.ref_objs() {
140            ObjectFormatHelper::encode_array(&mut map, "ref_objects", ref_objs);
141        }
142
143        if let Some(prev) = self.prev() {
144            JsonCodecHelper::encode_string_field(&mut map, "prev", prev);
145        }
146
147        if let Some(ts) = self.create_timestamp() {
148            JsonCodecHelper::encode_string_field_2(
149                &mut map,
150                "create_timestamp",
151                ts.to_hex_string(),
152            );
153        }
154
155        JsonCodecHelper::encode_string_field_2(
156            &mut map,
157            "create_time",
158            ObjectFormatHelper::format_time(self.create_time()),
159        );
160
161        if let Some(time) = self.expired_time() {
162            JsonCodecHelper::encode_string_field_2(
163                &mut map,
164                "expired_time",
165                ObjectFormatHelper::format_time(time),
166            );
167        }
168
169        if let Some(owner) = self.owner() {
170            JsonCodecHelper::encode_string_field(&mut map, "owner", owner);
171        }
172
173        if let Some(owner) = self.owner() {
174            JsonCodecHelper::encode_string_field(&mut map, "owner", owner);
175        }
176
177        if let Some(area) = self.area() {
178            ObjectFormatHelper::encode_field(&mut map, "area", area);
179        }
180
181        if let Some(pk) = self.public_key_ref() {
182            ObjectFormatHelper::encode_field(&mut map, "public_key", &pk);
183        }
184
185        ObjectFormatHelper::encode_field(&mut map, "content", self.content());
186
187        map.into()
188    }
189}
190
191impl ObjectFormat for Area {
192    fn format_json(&self) -> serde_json::Value {
193        let mut map = serde_json::Map::new();
194
195        JsonCodecHelper::encode_number_field(&mut map, "country", self.country);
196        JsonCodecHelper::encode_number_field(&mut map, "carrier", self.carrier);
197        JsonCodecHelper::encode_number_field(&mut map, "city", self.city);
198        JsonCodecHelper::encode_number_field(&mut map, "inner", self.inner);
199
200        map.into()
201    }
202}
203
204impl ObjectFormat for ObjectLink {
205    fn format_json(&self) -> serde_json::Value {
206        let mut map = serde_json::Map::new();
207        JsonCodecHelper::encode_string_field(&mut map, "object_id", &self.obj_id);
208        JsonCodecHelper::encode_option_string_field(&mut map, "owner", self.obj_owner.as_ref());
209
210        map.into()
211    }
212}
213
214impl<'a> ObjectFormat for PublicKeyRef<'a> {
215    fn format_json(&self) -> serde_json::Value {
216        match self {
217            PublicKeyRef::Single(pk) => pk.format_json(),
218            PublicKeyRef::MN(pk) => pk.format_json(),
219        }
220    }
221}
222
223impl ObjectFormat for PublicKeyValue {
224    fn format_json(&self) -> serde_json::Value {
225        self.as_ref().format_json()
226    }
227}
228
229impl ObjectFormat for PublicKey {
230    fn format_json(&self) -> serde_json::Value {
231        let mut map = serde_json::Map::new();
232
233        JsonCodecHelper::encode_string_field(&mut map, "type", self.key_type_str());
234
235        let raw = self.to_vec().unwrap();
236        map.insert("raw_data".to_string(), Value::String(hex::encode(&raw)));
237
238        map.into()
239    }
240}
241
242impl ObjectFormat for MNPublicKey {
243    fn format_json(&self) -> serde_json::Value {
244        let mut map = serde_json::Map::new();
245
246        JsonCodecHelper::encode_number_field(&mut map, "index", self.0);
247        ObjectFormatHelper::encode_array(&mut map, "value", &self.1);
248
249        map.into()
250    }
251}
252
253impl ObjectFormat for SignData {
254    fn format_json(&self) -> serde_json::Value {
255        let mut map = serde_json::Map::new();
256
257        JsonCodecHelper::encode_string_field(&mut map, "type", self.sign_type());
258
259        map.insert(
260            "raw_data".to_string(),
261            Value::String(hex::encode(self.as_slice())),
262        );
263
264        map.into()
265    }
266}
267
268impl ObjectFormat for SignatureSource {
269    fn format_json(&self) -> serde_json::Value {
270        let mut map = serde_json::Map::new();
271
272        match self {
273            Self::RefIndex(index) => {
274                JsonCodecHelper::encode_string_field(&mut map, "type", "ref_index");
275                JsonCodecHelper::encode_number_field(&mut map, "value", *index);
276            }
277            Self::Object(link) => {
278                JsonCodecHelper::encode_string_field(&mut map, "type", "object");
279                ObjectFormatHelper::encode_field(&mut map, "value", link);
280            }
281            Self::Key(pk) => {
282                JsonCodecHelper::encode_string_field(&mut map, "type", "key");
283                ObjectFormatHelper::encode_field(&mut map, "value", pk);
284            }
285        }
286
287        map.into()
288    }
289}
290
291impl ObjectFormat for Signature {
292    fn format_json(&self) -> serde_json::Value {
293        let mut map = serde_json::Map::new();
294
295        ObjectFormatHelper::encode_field(&mut map, "sign_source", self.sign_source());
296        JsonCodecHelper::encode_number_field(
297            &mut map,
298            "sign_key_index",
299            self.sign_key_index() as i32,
300        );
301        JsonCodecHelper::encode_string_field(&mut map, "sign_time", &self.sign_time());
302        ObjectFormatHelper::encode_field(&mut map, "sign", self.sign());
303
304        map.into()
305    }
306}
307
308impl ObjectFormat for ObjectSigns {
309    fn format_json(&self) -> serde_json::Value {
310        let mut map = serde_json::Map::new();
311
312        if let Some(signs) = self.desc_signs() {
313            ObjectFormatHelper::encode_array(&mut map, "desc_signs", signs);
314        }
315
316        if let Some(signs) = self.body_signs() {
317            ObjectFormatHelper::encode_array(&mut map, "body_signs", signs);
318        }
319
320        map.into()
321    }
322}
323
324impl<B, O> ObjectFormat for ObjectMutBody<B, O>
325where
326    O: ObjectType,
327    B: BodyContent + ObjectFormat,
328{
329    fn format_json(&self) -> serde_json::Value {
330        let mut map = serde_json::Map::new();
331
332        if let Some(prev) = self.prev_version() {
333            JsonCodecHelper::encode_string_field_2(&mut map, "prev_version", prev.to_hex_string());
334        }
335
336        JsonCodecHelper::encode_string_field_2(
337            &mut map,
338            "update_time",
339            ObjectFormatHelper::format_time(self.update_time()),
340        );
341
342        ObjectFormatHelper::encode_field(&mut map, "content", self.content());
343
344        if let Some(data) = self.user_data() {
345            JsonCodecHelper::encode_string_field_2(&mut map, "user_data", hex::encode(data));
346        }
347
348        map.into()
349    }
350}
351
352impl<O> ObjectFormat for NamedObjectBase<O>
353where
354    O: ObjectType,
355    O::DescType: ObjectFormat,
356    O::ContentType: BodyContent + ObjectFormat,
357    NamedObjectBase<O>: NamedObject<O>,
358{
359    fn format_json(&self) -> serde_json::Value {
360        let mut map = serde_json::Map::new();
361
362        ObjectFormatHelper::encode_field(&mut map, "desc", self.desc());
363
364        if let Some(body) = self.body() {
365            ObjectFormatHelper::encode_field(&mut map, "body", body);
366        }
367
368        let signs = self.signs();
369        if !signs.is_empty() {
370            ObjectFormatHelper::encode_field(&mut map, "signs", signs);
371        }
372
373        if let Some(nonce) = self.nonce() {
374            JsonCodecHelper::encode_string_field(&mut map, "nonce", &nonce);
375        }
376
377        map.into()
378    }
379}
380
381fn encode_content_codec(version: u8, format: u8) -> serde_json::Value {
382    let mut map = serde_json::Map::new();
383
384    JsonCodecHelper::encode_number_field(&mut map, "version", version);
385    JsonCodecHelper::encode_number_field(&mut map, "format", format);
386
387    map.into()
388}
389
390impl ObjectFormat for TypelessObjectDesc {
391    fn format_json(&self) -> serde_json::Value {
392        let mut map = serde_json::Map::new();
393
394        let t = self.obj_type();
395        JsonCodecHelper::encode_number_field(&mut map, "object_type", t);
396
397        let object_id = self.calculate_id();
398        JsonCodecHelper::encode_string_field(&mut map, "object_id", &object_id);
399
400        JsonCodecHelper::encode_string_field(
401            &mut map,
402            "object_category",
403            &object_id.object_category(),
404        );
405
406        JsonCodecHelper::encode_string_field_2(
407            &mut map,
408            "object_type_code",
409            format!("{:?}", object_id.obj_type_code()),
410        );
411
412        if let Some(dec_id) = self.dec_id() {
413            JsonCodecHelper::encode_string_field(&mut map, "dec_id", dec_id);
414        }
415
416        if let Some(ref_objs) = self.ref_objs() {
417            ObjectFormatHelper::encode_array(&mut map, "ref_objects", ref_objs);
418        }
419
420        if let Some(prev) = self.prev() {
421            JsonCodecHelper::encode_string_field(&mut map, "prev", prev);
422        }
423
424        if let Some(ts) = self.create_timestamp() {
425            JsonCodecHelper::encode_string_field_2(
426                &mut map,
427                "create_timestamp",
428                ts.to_hex_string(),
429            );
430        }
431
432        JsonCodecHelper::encode_string_field(&mut map, "create_time", &self.create_time());
433
434        if let Some(time) = self.expired_time() {
435            JsonCodecHelper::encode_string_field(&mut map, "expired_time", &time);
436        }
437
438        if let Some(owner) = self.owner() {
439            JsonCodecHelper::encode_string_field(&mut map, "owner", owner);
440        }
441
442        if let Some(owner) = self.owner() {
443            JsonCodecHelper::encode_string_field(&mut map, "owner", owner);
444        }
445
446        if let Some(area) = self.area() {
447            ObjectFormatHelper::encode_field(&mut map, "area", area);
448        }
449
450        if let Some(pk) = self.public_key() {
451            ObjectFormatHelper::encode_field(&mut map, "public_key", &pk);
452        }
453
454        map.insert(
455            "content_codec".to_string(),
456            encode_content_codec(self.version(), self.format()),
457        );
458        info!("encode typeless core object to json");
459        JsonCodecHelper::encode_string_field_2(&mut map, "content", hex::encode(self.content()));
460
461        map.into()
462    }
463}
464
465impl ObjectFormat for TypelessObjectBodyContent {
466    fn format_json(&self) -> serde_json::Value {
467        let mut map = serde_json::Map::new();
468
469        map.insert(
470            "content_codec".to_string(),
471            encode_content_codec(self.version(), self.format()),
472        );
473        JsonCodecHelper::encode_string_field_2(&mut map, "content", hex::encode(self.data()));
474
475        map.into()
476    }
477}
478
479impl ObjectFormat for StandardObject {
480    fn format_json(&self) -> serde_json::Value {
481        match self {
482            StandardObject::Device(o) => o.format_json(),
483            StandardObject::People(o) => o.format_json(),
484            StandardObject::SimpleGroup(o) => o.format_json(),
485            StandardObject::Org(o) => o.format_json(),
486            StandardObject::AppGroup(o) => o.format_json(),
487            StandardObject::UnionAccount(o) => o.format_json(),
488            StandardObject::ChunkId(chunk_id) => chunk_id.format_json(),
489            StandardObject::File(o) => o.format_json(),
490            StandardObject::Dir(o) => o.format_json(),
491            StandardObject::Diff(o) => o.format_json(),
492            StandardObject::ProofOfService(o) => o.format_json(),
493            StandardObject::Tx(o) => o.format_json(),
494            StandardObject::Action(o) => o.format_json(),
495            StandardObject::ObjectMap(o) => o.format_json(),
496            StandardObject::Contract(o) => o.format_json(),
497        }
498    }
499}
500
501impl ObjectFormat for AnyNamedObject {
502    fn format_json(&self) -> serde_json::Value {
503        match self {
504            AnyNamedObject::Standard(o) => o.format_json(),
505            AnyNamedObject::Core(o) => o.format_json(),
506            AnyNamedObject::DECApp(o) => o.format_json(),
507        }
508    }
509}
510
511// device
512impl ObjectFormat for DeviceDescContent {
513    fn format_json(&self) -> serde_json::Value {
514        let mut map = serde_json::Map::new();
515
516        JsonCodecHelper::encode_string_field(&mut map, "unique_id", &self.unique_id());
517
518        map.into()
519    }
520}
521
522impl ObjectFormat for DeviceBodyContent {
523    fn format_json(&self) -> serde_json::Value {
524        let mut map = serde_json::Map::new();
525
526        JsonCodecHelper::encode_str_array_field(&mut map, "endpoints", &self.endpoints());
527        JsonCodecHelper::encode_str_array_field(&mut map, "sn_list", &self.sn_list());
528        JsonCodecHelper::encode_str_array_field(
529            &mut map,
530            "passive_pn_list",
531            &self.passive_pn_list(),
532        );
533
534        JsonCodecHelper::encode_option_string_field(&mut map, "name", self.name());
535        JsonCodecHelper::encode_option_number_field(&mut map, "bdt_version", self.bdt_version());
536
537        map.into()
538    }
539}
540
541// people
542impl ObjectFormat for PeopleDescContent {
543    fn format_json(&self) -> serde_json::Value {
544        let map = serde_json::Map::new();
545
546        map.into()
547    }
548}
549
550impl ObjectFormat for PeopleBodyContent {
551    fn format_json(&self) -> serde_json::Value {
552        let mut map = serde_json::Map::new();
553
554        JsonCodecHelper::encode_string_field(&mut map, "ood_work_mode", &self.ood_work_mode());
555        JsonCodecHelper::encode_str_array_field(&mut map, "ood_list", &self.ood_list());
556        JsonCodecHelper::encode_option_string_field(&mut map, "name", self.name());
557        JsonCodecHelper::encode_option_string_field(&mut map, "icon", self.icon());
558
559        map.into()
560    }
561}
562
563// simple group
564impl ObjectFormat for SimpleGroupDescContent {
565    fn format_json(&self) -> serde_json::Value {
566        let map = serde_json::Map::new();
567
568        map.into()
569    }
570}
571
572impl ObjectFormat for SimpleGroupBodyContent {
573    fn format_json(&self) -> serde_json::Value {
574        let mut map = serde_json::Map::new();
575
576        JsonCodecHelper::encode_str_array_field(&mut map, "members", self.members());
577        JsonCodecHelper::encode_str_array_field(&mut map, "ood_list", &self.ood_list());
578        JsonCodecHelper::encode_string_field(&mut map, "ood_work_mode", &self.ood_work_mode());
579
580        map.into()
581    }
582}
583
584// org
585impl ObjectFormat for OrgDescContent {
586    fn format_json(&self) -> serde_json::Value {
587        let map = serde_json::Map::new();
588
589        map.into()
590    }
591}
592
593impl ObjectFormatAutoWithSerde for OrgBodyContent {}
594
595// appgroup
596impl ObjectFormat for AppGroupDescContent {
597    fn format_json(&self) -> serde_json::Value {
598        let map = serde_json::Map::new();
599
600        map.into()
601    }
602}
603impl ObjectFormat for AppGroupBodyContent {
604    fn format_json(&self) -> serde_json::Value {
605        let map = serde_json::Map::new();
606
607        map.into()
608    }
609}
610
611// union account
612impl ObjectFormatAutoWithSerde for UnionAccountDescContent {}
613
614impl ObjectFormat for UnionAccountBodyContent {
615    fn format_json(&self) -> serde_json::Value {
616        let map = serde_json::Map::new();
617
618        map.into()
619    }
620}
621
622// chunk_id
623impl ObjectFormat for ChunkId {
624    fn format_json(&self) -> serde_json::Value {
625        let mut map = serde_json::Map::new();
626
627        JsonCodecHelper::encode_string_field(&mut map, "chunk_id", self);
628        JsonCodecHelper::encode_string_field(&mut map, "len", &self.len());
629        JsonCodecHelper::encode_string_field_2(&mut map, "hash_value", hex::encode(self.hash()));
630
631        map.into()
632    }
633}
634
635// file
636impl ObjectFormat for FileDescContent {
637    fn format_json(&self) -> serde_json::Value {
638        let mut map = serde_json::Map::new();
639
640        JsonCodecHelper::encode_string_field(&mut map, "len", &self.len());
641        JsonCodecHelper::encode_string_field_2(&mut map, "hash_value", self.hash().to_hex_string());
642
643        map.into()
644    }
645}
646
647impl ObjectFormat for ChunkBundle {
648    fn format_json(&self) -> serde_json::Value {
649        let mut map = serde_json::Map::new();
650
651        JsonCodecHelper::encode_str_array_field(&mut map, "list", self.chunk_list());
652        JsonCodecHelper::encode_string_field(&mut map, "hash_method", self.hash_method().as_str());
653
654        map.into()
655    }
656}
657
658impl ObjectFormat for ChunkList {
659    fn format_json(&self) -> serde_json::Value {
660        let mut map = serde_json::Map::new();
661
662        match self {
663            Self::ChunkInList(list) => {
664                JsonCodecHelper::encode_str_array_field(&mut map, "chunk_in_list", list);
665            }
666            Self::ChunkInFile(file_id) => {
667                JsonCodecHelper::encode_string_field(&mut map, "chunk_in_file", &file_id);
668            }
669            Self::ChunkInBundle(bundle) => {
670                ObjectFormatHelper::encode_field(&mut map, "chunk_in_bundle", bundle);
671            }
672        }
673
674        map.into()
675    }
676}
677
678impl ObjectFormat for FileBodyContent {
679    fn format_json(&self) -> serde_json::Value {
680        let mut map = serde_json::Map::new();
681
682        ObjectFormatHelper::encode_field(&mut map, "chunk_list", self.chunk_list());
683
684        map.into()
685    }
686}
687
688// dir
689impl ObjectFormat for Attributes {
690    fn format_json(&self) -> serde_json::Value {
691        let mut map = serde_json::Map::new();
692
693        JsonCodecHelper::encode_number_field(&mut map, "flags", self.flags());
694
695        map.into()
696    }
697}
698
699impl ObjectFormat for InnerNode {
700    fn format_json(&self) -> serde_json::Value {
701        let mut map = serde_json::Map::new();
702
703        match self {
704            Self::ObjId(id) => {
705                JsonCodecHelper::encode_string_field(&mut map, "object_id", id);
706            }
707            Self::Chunk(id) => {
708                JsonCodecHelper::encode_string_field(&mut map, "chunk", id);
709            }
710            Self::IndexInParentChunk(begin, end) => {
711                let range = format!("[{},{})", begin, end);
712                JsonCodecHelper::encode_string_field_2(&mut map, "index_in_parent_chunk", range);
713            }
714        }
715
716        map.into()
717    }
718}
719
720impl ObjectFormat for DirBodyDescObjectMap {
721    fn format_json(&self) -> serde_json::Value {
722        let mut list = Vec::with_capacity(self.len());
723
724        for (key, value) in self {
725            let mut map = serde_json::Map::new();
726            JsonCodecHelper::encode_string_field(&mut map, "name", key);
727            ObjectFormatHelper::encode_field(&mut map, "attributes", value.attributes());
728            ObjectFormatHelper::encode_field(&mut map, "node", value.node());
729
730            list.push(serde_json::Value::Object(map));
731        }
732
733        serde_json::Value::Array(list)
734    }
735}
736
737impl ObjectFormat for NDNObjectList {
738    fn format_json(&self) -> serde_json::Value {
739        let mut map = serde_json::Map::new();
740
741        if let Some(parent_chunk) = self.parent_chunk() {
742            ObjectFormatHelper::encode_field(&mut map, "parent_chunk", parent_chunk);
743        }
744
745        ObjectFormatHelper::encode_field(&mut map, "object_map", self.object_map());
746        map.into()
747    }
748}
749
750impl ObjectFormat for NDNObjectInfo {
751    fn format_json(&self) -> serde_json::Value {
752        let mut map = serde_json::Map::new();
753
754        match self {
755            Self::Chunk(chunk_id) => {
756                ObjectFormatHelper::encode_field(&mut map, "chunk", chunk_id);
757            }
758            Self::ObjList(list) => {
759                ObjectFormatHelper::encode_field(&mut map, "object_list", list);
760            }
761        }
762        map.into()
763    }
764}
765
766impl ObjectFormat for DirDescContent {
767    fn format_json(&self) -> serde_json::Value {
768        let mut map = serde_json::Map::new();
769
770        ObjectFormatHelper::encode_field(&mut map, "attributes", self.attributes());
771        ObjectFormatHelper::encode_field(&mut map, "object_list", self.obj_list());
772
773        map.into()
774    }
775}
776
777impl ObjectFormat for DirBodyContentObjectList {
778    fn format_json(&self) -> serde_json::Value {
779        let list: Vec<ObjectId> = self.iter().map(|(key, _)| key.to_owned()).collect();
780
781        serde_json::to_value(list).unwrap()
782    }
783}
784
785impl ObjectFormat for DirBodyContent {
786    fn format_json(&self) -> serde_json::Value {
787        let mut map = serde_json::Map::new();
788
789        match self {
790            Self::Chunk(chunk_id) => ObjectFormatHelper::encode_field(&mut map, "chunk", chunk_id),
791            Self::ObjList(list) => {
792                ObjectFormatHelper::encode_field(&mut map, "object_list", list);
793            }
794        }
795
796        map.into()
797    }
798}
799
800// diff
801impl ObjectFormat for DiffDescContent {
802    fn format_json(&self) -> serde_json::Value {
803        let mut map = serde_json::Map::new();
804
805        JsonCodecHelper::encode_string_field(&mut map, "file_id", self.file_id());
806        JsonCodecHelper::encode_str_array_field(&mut map, "diff_list", self.diff_list());
807
808        map.into()
809    }
810}
811object_format_empty_impl!(DiffBodyContent);
812
813// ProofOfService
814object_format_not_impl!(ProofOfServiceDescContent<ProofData>);
815object_format_not_impl!(ProofOfServiceBodyContent<ProofData>);
816
817// Tx
818object_format_not_impl!(TxDescContent<TxBody>);
819object_format_not_impl!(TxBodyContent);
820
821// action
822object_format_empty_impl!(ActionDescContent);
823object_format_empty_impl!(ActionBodyContent);
824
825// Contract
826object_format_not_impl!(ContractDescContent<ContractData>);
827object_format_not_impl!(ContractBodyContent<ContractData>);
828
829// ObjectMap
830impl ObjectFormat for SimpleContent {
831    fn format_json(&self) -> serde_json::Value {
832        match self {
833            Self::Map(content) => serde_json::to_value(content.values()).unwrap(),
834            Self::DiffMap(content) => serde_json::to_value(content.values()).unwrap(),
835            Self::Set(content) => serde_json::to_value(content.values()).unwrap(),
836            Self::DiffSet(content) => serde_json::to_value(content.values()).unwrap(),
837        }
838    }
839}
840
841impl ObjectFormat for ObjectMapSimpleContent {
842    fn format_json(&self) -> serde_json::Value {
843        self.content().format_json()
844    }
845}
846
847impl ObjectFormat for ObjectMapHubContent {
848    fn format_json(&self) -> serde_json::Value {
849        serde_json::to_value(self.subs()).unwrap()
850    }
851}
852
853impl ObjectFormat for ObjectMapContent {
854    fn format_json(&self) -> serde_json::Value {
855        match self {
856            Self::Simple(content) => content.format_json(),
857            Self::Hub(content) => content.format_json(),
858        }
859    }
860}
861
862impl ObjectFormat for ObjectMapDescContent {
863    fn format_json(&self) -> serde_json::Value {
864        let mut map = serde_json::Map::new();
865
866        JsonCodecHelper::encode_string_field(&mut map, "class", self.class().as_str());
867
868        JsonCodecHelper::encode_string_field(&mut map, "count", &self.count());
869        JsonCodecHelper::encode_string_field(&mut map, "size", &self.size());
870
871        JsonCodecHelper::encode_number_field(&mut map, "depth", self.depth());
872
873        JsonCodecHelper::encode_string_field_2(
874            &mut map,
875            "content_type",
876            self.content_type().to_string(),
877        );
878        JsonCodecHelper::encode_string_field_2(&mut map, "content_mode", self.mode().to_string());
879
880        ObjectFormatHelper::encode_field(&mut map, "content", self.content());
881
882        map.into()
883    }
884}
885
886object_format_empty_impl!(ObjectMapBodyContent);
887
888impl ObjectFormatAutoWithSerde for EmptyProtobufBodyContent {}
889impl ObjectFormatAutoWithSerde for EmptyBodyContent {}
890
891#[test]
892fn test() {
893    let owner = ObjectId::default();
894    let hash = HashValue::default();
895
896    let chunk_list = vec![ChunkId::default(), ChunkId::default()];
897
898    let chunk_list = ChunkList::ChunkInList(chunk_list);
899
900    let file = File::new(owner, 100, hash, chunk_list)
901        .no_create_time()
902        .build();
903
904    let value = file.desc().format_json();
905    let s = value.to_string();
906    println!("{}", s);
907
908    let secret = PrivateKey::generate_rsa(1024).unwrap();
909    let public = secret.public();
910    let mut device = Device::new(Some(owner), UniqueId::default(),
911                             vec![], vec![], vec![],
912                             public, Area::new(1,2,3,4), DeviceCategory::OOD).build();
913    device.set_bdt_version(Some(2));
914
915    println!("new device obj: {}", device.format_json().to_string());
916
917    let (mut old_device, _) = Device::decode_from_file("c:\\cyfs\\etc\\desc\\device.desc".as_ref(), &mut vec![]).unwrap();
918
919    println!("old device obj: {}", old_device.format_json().to_string());
920
921    old_device.set_bdt_version(Some(5));
922    println!("old device set bdt ver obj: {}", old_device.format_json().to_string());
923}
924
925use std::collections::{hash_map::Entry, HashMap};
926use std::sync::{Arc, Mutex};
927
928pub fn format_json<T: for<'de> RawDecode<'de> + ObjectFormat>(
929    buf: &[u8],
930) -> BuckyResult<serde_json::Value> {
931    let (obj, _) = T::raw_decode(buf)?;
932
933    Ok(obj.format_json())
934}
935
936pub struct FormatFactory {
937    ext_types: Mutex<
938        HashMap<u16, Arc<Box<dyn Fn(&[u8]) -> BuckyResult<serde_json::Value> + Send + Sync>>>,
939    >,
940}
941
942impl FormatFactory {
943    pub fn new() -> Self {
944        Self {
945            ext_types: Mutex::new(HashMap::new()),
946        }
947    }
948
949    pub fn register<F: 'static + Fn(&[u8]) -> BuckyResult<serde_json::Value> + Send + Sync>(
950        &self,
951        obj_type: impl Into<u16>,
952        formater: F,
953    ) {
954        let f = Arc::new(Box::new(formater)
955            as Box<dyn Fn(&[u8]) -> BuckyResult<serde_json::Value> + Send + Sync>);
956
957        let mut all = self.ext_types.lock().unwrap();
958        let obj_type = obj_type.into();
959        match all.entry(obj_type) {
960            Entry::Vacant(v) => {
961                v.insert(f);
962            }
963            Entry::Occupied(mut o) => {
964                warn!("register ext object format but already exists! obj_type={}", obj_type);
965                o.insert(f);
966            }
967        }
968    }
969
970    pub fn format(&self, obj_type: u16, obj_raw: &[u8]) -> Option<serde_json::Value> {
971        let f = self
972            .ext_types
973            .lock()
974            .unwrap()
975            .get(&obj_type)
976            .map(|f| f.clone());
977        match f {
978            Some(f) => match f(obj_raw) {
979                Ok(r) => Some(r),
980                Err(_e) => None,
981            },
982            None => None,
983        }
984    }
985}
986
987lazy_static::lazy_static! {
988    pub static ref FORMAT_FACTORY: FormatFactory = FormatFactory::new();
989}
cyfs_base/codec/format.rs

cyfs_base/codec/
format.rs
