cyfs_lib/trans/
request_codec.rs

1use super::output_request::*;
2use crate::*;
3use cyfs_base::*;
4
5use cyfs_core::TransContext;
6use serde_json::{Map, Value};
7use std::str::{FromStr};
8
9impl JsonCodec<TransGetContextOutputRequest> for TransGetContextOutputRequest {
10    fn encode_json(&self) -> Map<String, Value> {
11        let mut obj = Map::new();
12        JsonCodecHelper::encode_field(&mut obj, "common", &self.common);
13        JsonCodecHelper::encode_option_string_field(
14            &mut obj,
15            "context_id",
16            self.context_id.as_ref(),
17        );
18        JsonCodecHelper::encode_option_string_field(
19            &mut obj,
20            "context_path",
21            self.context_path.as_ref(),
22        );
23
24        obj
25    }
26
27    fn decode_json(obj: &Map<String, Value>) -> BuckyResult<Self> {
28        Ok(Self {
29            common: JsonCodecHelper::decode_field(obj, "common")?,
30            context_id: JsonCodecHelper::decode_option_string_field(obj, "context_id")?,
31            context_path: JsonCodecHelper::decode_option_string_field(obj, "context_path")?,
32        })
33    }
34}
35
36impl JsonCodec<TransGetContextInputRequest> for TransGetContextInputRequest {
37    fn encode_json(&self) -> Map<String, Value> {
38        let mut obj = Map::new();
39        JsonCodecHelper::encode_field(&mut obj, "common", &self.common);
40        JsonCodecHelper::encode_option_string_field(
41            &mut obj,
42            "context_id",
43            self.context_id.as_ref(),
44        );
45        JsonCodecHelper::encode_option_string_field(
46            &mut obj,
47            "context_path",
48            self.context_path.as_ref(),
49        );
50
51        obj
52    }
53
54    fn decode_json(obj: &Map<String, Value>) -> BuckyResult<Self> {
55        Ok(Self {
56            common: JsonCodecHelper::decode_field(obj, "common")?,
57            context_id: JsonCodecHelper::decode_option_string_field(obj, "context_id")?,
58            context_path: JsonCodecHelper::decode_option_string_field(obj, "context_path")?,
59        })
60    }
61}
62
63impl JsonCodec<TransPutContextOutputRequest> for TransPutContextOutputRequest {
64    fn encode_json(&self) -> Map<String, Value> {
65        let mut obj = Map::new();
66        JsonCodecHelper::encode_field(&mut obj, "common", &self.common);
67        JsonCodecHelper::encode_string_field(&mut obj, "context", &self.context.to_hex().unwrap());
68        if let Some(access) = &self.access {
69            JsonCodecHelper::encode_number_field(&mut obj, "access", access.value());
70        }
71
72        obj
73    }
74
75    fn decode_json(obj: &Map<String, Value>) -> BuckyResult<Self> {
76        let context = TransContext::clone_from_hex(
77            JsonCodecHelper::decode_string_field::<String>(obj, "context")?.as_str(),
78            &mut Vec::new(),
79        )?;
80        let access: Option<u32> = JsonCodecHelper::decode_option_int_field(obj, "access")?;
81        let access = access.map(|v| AccessString::new(v));
82
83        Ok(Self {
84            common: JsonCodecHelper::decode_field(obj, "common")?,
85            context,
86            access,
87        })
88    }
89}
90
91impl JsonCodec<TransUpdateContextInputRequest> for TransUpdateContextInputRequest {
92    fn encode_json(&self) -> Map<String, Value> {
93        let mut obj = Map::new();
94        JsonCodecHelper::encode_field(&mut obj, "common", &self.common);
95        JsonCodecHelper::encode_string_field(&mut obj, "context", &self.context.to_hex().unwrap());
96        if let Some(access) = &self.access {
97            JsonCodecHelper::encode_number_field(&mut obj, "access", access.value());
98        }
99
100        obj
101    }
102
103    fn decode_json(obj: &Map<String, Value>) -> BuckyResult<Self> {
104        let context = TransContext::clone_from_hex(
105            JsonCodecHelper::decode_string_field::<String>(obj, "context")?.as_str(),
106            &mut Vec::new(),
107        )?;
108        let access: Option<u32> = JsonCodecHelper::decode_option_int_field(obj, "access")?;
109        let access = access.map(|v| AccessString::new(v));
110        Ok(Self {
111            common: JsonCodecHelper::decode_field(obj, "common")?,
112            context,
113            access,
114        })
115    }
116}
117
118impl JsonCodec<TransCreateTaskOutputRequest> for TransCreateTaskOutputRequest {
119    fn encode_json(&self) -> Map<String, Value> {
120        let mut obj = Map::new();
121
122        JsonCodecHelper::encode_field(&mut obj, "common", &self.common);
123
124        JsonCodecHelper::encode_string_field(&mut obj, "object_id", &self.object_id);
125
126        let local_path = self.local_path.to_str().unwrap_or_else(|| {
127            error!(
128                "invalid utf-8 local_path value: {}",
129                self.local_path.display()
130            );
131            ""
132        });
133        obj.insert(
134            "local_path".to_owned(),
135            Value::String(local_path.to_string()),
136        );
137
138        JsonCodecHelper::encode_str_array_field(&mut obj, "device_list", &self.device_list);
139
140        JsonCodecHelper::encode_option_string_field(&mut obj, "group", self.group.as_ref());
141        JsonCodecHelper::encode_option_string_field(&mut obj, "context", self.context.as_ref());
142
143        JsonCodecHelper::encode_bool_field(&mut obj, "auto_start", self.auto_start);
144        obj
145    }
146
147    fn decode_json(obj: &Map<String, Value>) -> BuckyResult<Self> {
148        Ok(Self {
149            common: JsonCodecHelper::decode_field(obj, "common")?,
150            object_id: JsonCodecHelper::decode_string_field(obj, "object_id")?,
151            local_path: JsonCodecHelper::decode_string_field(obj, "local_path")?,
152            device_list: JsonCodecHelper::decode_str_array_field(obj, "device_list")?,
153            group: JsonCodecHelper::decode_option_string_field(obj, "group")?,
154            context: JsonCodecHelper::decode_option_string_field(obj, "context")?,
155            auto_start: JsonCodecHelper::decode_bool_field(obj, "auto_start")?,
156        })
157    }
158}
159
160impl JsonCodec<TransCreateTaskInputRequest> for TransCreateTaskInputRequest {
161    fn encode_json(&self) -> Map<String, Value> {
162        let mut obj = Map::new();
163
164        JsonCodecHelper::encode_field(&mut obj, "common", &self.common);
165
166        JsonCodecHelper::encode_string_field(&mut obj, "object_id", &self.object_id);
167
168        let local_path = self.local_path.to_str().unwrap_or_else(|| {
169            error!(
170                "invalid utf-8 local_path value: {}",
171                self.local_path.display()
172            );
173            ""
174        });
175        obj.insert(
176            "local_path".to_owned(),
177            Value::String(local_path.to_string()),
178        );
179
180        JsonCodecHelper::encode_str_array_field(&mut obj, "device_list", &self.device_list);
181
182        JsonCodecHelper::encode_option_string_field(&mut obj, "group", self.group.as_ref());
183        JsonCodecHelper::encode_option_string_field(&mut obj, "context", self.context.as_ref());
184
185        JsonCodecHelper::encode_bool_field(&mut obj, "auto_start", self.auto_start);
186        obj
187    }
188
189    fn decode_json(obj: &Map<String, Value>) -> BuckyResult<Self> {
190        Ok(Self {
191            common: JsonCodecHelper::decode_field(obj, "common")?,
192            object_id: JsonCodecHelper::decode_string_field(obj, "object_id")?,
193            local_path: JsonCodecHelper::decode_string_field(obj, "local_path")?,
194            device_list: JsonCodecHelper::decode_str_array_field(obj, "device_list")?,
195            group: JsonCodecHelper::decode_option_string_field(obj, "group")?,
196            context: JsonCodecHelper::decode_option_string_field(obj, "context")?,
197            auto_start: JsonCodecHelper::decode_bool_field(obj, "auto_start")?,
198        })
199    }
200}
201
202impl JsonCodec<TransControlTaskOutputRequest> for TransControlTaskOutputRequest {
203    fn encode_json(&self) -> Map<String, Value> {
204        let mut obj = Map::new();
205        JsonCodecHelper::encode_field(&mut obj, "common", &self.common);
206        JsonCodecHelper::encode_string_field(&mut obj, "task_id", &self.task_id);
207        JsonCodecHelper::encode_string_field(&mut obj, "action", &self.action);
208        obj
209    }
210
211    fn decode_json(obj: &Map<String, Value>) -> BuckyResult<Self> {
212        Ok(Self {
213            common: JsonCodecHelper::decode_field(obj, "common")?,
214            task_id: JsonCodecHelper::decode_string_field(obj, "task_id")?,
215            action: JsonCodecHelper::decode_string_field(obj, "action")?,
216        })
217    }
218}
219
220impl JsonCodec<TransControlTaskInputRequest> for TransControlTaskInputRequest {
221    fn encode_json(&self) -> Map<String, Value> {
222        let mut obj = Map::new();
223        JsonCodecHelper::encode_field(&mut obj, "common", &self.common);
224        JsonCodecHelper::encode_string_field(&mut obj, "task_id", &self.task_id);
225        JsonCodecHelper::encode_string_field(&mut obj, "action", &self.action);
226        obj
227    }
228
229    fn decode_json(obj: &Map<String, Value>) -> BuckyResult<Self> {
230        Ok(Self {
231            common: JsonCodecHelper::decode_field(obj, "common")?,
232            task_id: JsonCodecHelper::decode_string_field(obj, "task_id")?,
233            action: JsonCodecHelper::decode_string_field(obj, "action")?,
234        })
235    }
236}
237
238impl JsonCodec<TransGetTaskStateOutputRequest> for TransGetTaskStateOutputRequest {
239    fn encode_json(&self) -> Map<String, Value> {
240        let mut obj = Map::new();
241
242        JsonCodecHelper::encode_field(&mut obj, "common", &self.common);
243        obj.insert("task_id".to_owned(), Value::String(self.task_id.clone()));
244        obj
245    }
246
247    fn decode_json(obj: &Map<String, Value>) -> BuckyResult<Self> {
248        Ok(Self {
249            common: JsonCodecHelper::decode_field(obj, "common")?,
250            task_id: JsonCodecHelper::decode_string_field(obj, "task_id")?,
251        })
252    }
253}
254
255impl JsonCodec<TransGetTaskStateInputRequest> for TransGetTaskStateInputRequest {
256    fn encode_json(&self) -> Map<String, Value> {
257        let mut obj = Map::new();
258
259        JsonCodecHelper::encode_field(&mut obj, "common", &self.common);
260        obj.insert("task_id".to_owned(), Value::String(self.task_id.clone()));
261        obj
262    }
263
264    fn decode_json(obj: &Map<String, Value>) -> BuckyResult<Self> {
265        Ok(Self {
266            common: JsonCodecHelper::decode_field(obj, "common")?,
267            task_id: JsonCodecHelper::decode_string_field(obj, "task_id")?,
268        })
269    }
270}
271
272impl JsonCodec<TransPublishFileOutputRequest> for TransPublishFileOutputRequest {
273    fn encode_json(&self) -> Map<String, Value> {
274        let mut obj = Map::new();
275
276        JsonCodecHelper::encode_field(&mut obj, "common", &self.common);
277        obj.insert("owner".to_owned(), Value::String(self.owner.to_string()));
278
279        let local_path = self.local_path.to_str().unwrap_or_else(|| {
280            error!(
281                "invalid utf-8 local_path value: {}",
282                self.local_path.display()
283            );
284            ""
285        });
286        obj.insert(
287            "local_path".to_owned(),
288            Value::String(local_path.to_string()),
289        );
290
291        obj.insert(
292            "chunk_size".to_owned(),
293            Value::String(self.chunk_size.to_string()),
294        );
295        JsonCodecHelper::encode_option_string_field(&mut obj, "chunk_method", Some(format!("{:?}", self.chunk_method)).as_ref());
296        JsonCodecHelper::encode_option_string_field(&mut obj, "file_id", self.file_id.as_ref());
297
298        if let Some(dirs) = &self.dirs {
299            let node = JsonCodecHelper::encode_to_array(dirs);
300            obj.insert("dirs".to_owned(), node);
301        }
302
303        if let Some(access) = &self.access {
304            JsonCodecHelper::encode_number_field(&mut obj, "access", access.value());
305        }
306
307        obj
308    }
309
310    fn decode_json(obj: &Map<String, Value>) -> BuckyResult<Self> {
311        let access: Option<u32> = JsonCodecHelper::decode_option_int_field(obj, "access")?;
312        let access = access.map(|v| AccessString::new(v));
313
314        Ok(Self {
315            common: JsonCodecHelper::decode_field(obj, "common")?,
316            owner: JsonCodecHelper::decode_string_field(&obj, "owner")?,
317            local_path: JsonCodecHelper::decode_string_field(&obj, "local_path")?,
318            chunk_size: JsonCodecHelper::decode_int_field(&obj, "chunk_size")?,
319            chunk_method: JsonCodecHelper::decode_option_string_field(&obj, "chunk_method")?.unwrap_or(TransPublishChunkMethod::Track), 
320            dirs: JsonCodecHelper::decode_option_array_field(&obj, "dirs")?,
321            file_id: JsonCodecHelper::decode_option_string_field(obj, "file_id")?,
322            access,
323        })
324    }
325}
326
327impl JsonCodec<TransPublishFileInputRequest> for TransPublishFileInputRequest {
328    fn encode_json(&self) -> Map<String, Value> {
329        let mut obj = Map::new();
330
331        JsonCodecHelper::encode_field(&mut obj, "common", &self.common);
332        obj.insert("owner".to_owned(), Value::String(self.owner.to_string()));
333
334        let local_path = self.local_path.to_str().unwrap_or_else(|| {
335            error!(
336                "invalid utf-8 local_path value: {}",
337                self.local_path.display()
338            );
339            ""
340        });
341        JsonCodecHelper::encode_string_field(&mut obj, "local_path", local_path);
342        JsonCodecHelper::encode_number_field(&mut obj, "chunk_size", self.chunk_size);
343        JsonCodecHelper::encode_option_string_field(&mut obj, "chunk_method", Some(format!("{:?}", self.chunk_method)).as_ref());
344
345        JsonCodecHelper::encode_option_string_field(&mut obj, "file_id", self.file_id.as_ref());
346
347        JsonCodecHelper::encode_as_option_list(&mut obj, "dirs", self.dirs.as_ref());
348
349        if let Some(access) = &self.access {
350            JsonCodecHelper::encode_number_field(&mut obj, "access", access.value());
351        }
352
353        obj
354    }
355
356    fn decode_json(obj: &Map<String, Value>) -> BuckyResult<Self> {
357        let access: Option<u32> = JsonCodecHelper::decode_option_int_field(obj, "access")?;
358        let access = access.map(|v| AccessString::new(v));
359
360        Ok(Self {
361            common: JsonCodecHelper::decode_field(obj, "common")?,
362            owner: JsonCodecHelper::decode_string_field(&obj, "owner")?,
363            local_path: JsonCodecHelper::decode_string_field(&obj, "local_path")?,
364            chunk_size: JsonCodecHelper::decode_int_field(&obj, "chunk_size")?,
365            chunk_method: JsonCodecHelper::decode_option_string_field(&obj, "chunk_method")?.unwrap_or(TransPublishChunkMethod::Track), 
366            dirs: JsonCodecHelper::decode_option_array_field(&obj, "dirs")?,
367            file_id: JsonCodecHelper::decode_option_string_field(obj, "file_id")?,
368            access,
369        })
370    }
371}
372
373impl JsonCodecAutoWithSerde for TransPublishFileOutputResponse {}
374impl JsonCodecAutoWithSerde for TransPublishFileInputResponse {}
375
376impl JsonCodecAutoWithSerde for TransCreateTaskOutputResponse {}
377impl JsonCodecAutoWithSerde for TransCreateTaskInputResponse {}
378
379impl JsonCodec<TransTaskInfo> for TransTaskInfo {
380    fn encode_json(&self) -> Map<String, Value> {
381        let mut obj = Map::new();
382        JsonCodecHelper::encode_string_field(&mut obj, "task_id", &self.task_id);
383        if self.context.is_some() {
384            JsonCodecHelper::encode_string_field(
385                &mut obj,
386                "context",
387                self.context.as_ref().unwrap(),
388            );
389        }
390        JsonCodecHelper::encode_string_field(&mut obj, "object_id", &self.object_id);
391        JsonCodecHelper::encode_string_field(
392            &mut obj,
393            "local_path",
394            &self.local_path.to_string_lossy().to_string(),
395        );
396        JsonCodecHelper::encode_str_array_field(&mut obj, "device_list", &self.device_list);
397        obj
398    }
399
400    fn decode_json(obj: &Map<String, Value>) -> BuckyResult<TransTaskInfo> {
401        Ok(Self {
402            task_id: JsonCodecHelper::decode_string_field(obj, "task_id")?,
403            context: JsonCodecHelper::decode_option_string_field(obj, "context")?,
404            object_id: JsonCodecHelper::decode_string_field(obj, "object_id")?,
405            local_path: JsonCodecHelper::decode_string_field(obj, "local_path")?,
406            device_list: JsonCodecHelper::decode_str_array_field(obj, "device_list")?,
407        })
408    }
409}
410
411impl JsonCodec<TransQueryTasksOutputResponse> for TransQueryTasksOutputResponse {
412    fn encode_json(&self) -> Map<String, Value> {
413        let mut obj = Map::new();
414        JsonCodecHelper::encode_as_list(&mut obj, "task_list", &self.task_list);
415        obj
416    }
417
418    fn decode_json(obj: &Map<String, Value>) -> BuckyResult<TransQueryTasksOutputResponse> {
419        let task_list = JsonCodecHelper::decode_array_field(obj, "task_list")?;
420        Ok(TransQueryTasksOutputResponse { task_list })
421    }
422}
423
424impl JsonCodec<TransQueryTasksInputResponse> for TransQueryTasksInputResponse {
425    fn encode_json(&self) -> Map<String, Value> {
426        let mut obj = Map::new();
427        JsonCodecHelper::encode_as_list(&mut obj, "task_list", &self.task_list);
428        obj
429    }
430
431    fn decode_json(obj: &Map<String, Value>) -> BuckyResult<Self> {
432        let task_list = JsonCodecHelper::decode_array_field(obj, "task_list")?;
433        Ok(Self { task_list })
434    }
435}
436
437impl JsonCodec<TransQueryTasksOutputRequest> for TransQueryTasksOutputRequest {
438    fn encode_json(&self) -> Map<String, Value> {
439        let mut obj = Map::new();
440        JsonCodecHelper::encode_field(&mut obj, "common", &self.common);
441        JsonCodecHelper::encode_option_string_field(
442            &mut obj,
443            "task_status",
444            self.task_status.as_ref(),
445        );
446
447        if self.range.is_some() {
448            JsonCodecHelper::encode_string_field(
449                &mut obj,
450                "offset",
451                &self.range.as_ref().unwrap().0,
452            );
453            JsonCodecHelper::encode_string_field(
454                &mut obj,
455                "length",
456                &self.range.as_ref().unwrap().1,
457            );
458        }
459        obj
460    }
461
462    fn decode_json(obj: &Map<String, Value>) -> BuckyResult<TransQueryTasksOutputRequest> {
463        let task_status = match obj.get("task_status") {
464            Some(task_status) => Some(JsonCodecHelper::decode_from_string(task_status)?),
465            None => None,
466        };
467
468        let offset = match obj.get("offset") {
469            Some(offset) => Some(JsonCodecHelper::decode_from_string(offset)?),
470            None => None,
471        };
472
473        let length = match obj.get("length") {
474            Some(length) => Some(JsonCodecHelper::decode_from_string(length)?),
475            None => None,
476        };
477
478        let range = if offset.is_some() && length.is_some() {
479            Some((offset.unwrap(), length.unwrap()))
480        } else {
481            None
482        };
483
484        Ok(Self {
485            common: JsonCodecHelper::decode_field(obj, "common")?,
486            task_status,
487            range,
488        })
489    }
490}
491
492impl JsonCodec<TransQueryTasksInputRequest> for TransQueryTasksInputRequest {
493    fn encode_json(&self) -> Map<String, Value> {
494        let mut obj = Map::new();
495        JsonCodecHelper::encode_field(&mut obj, "common", &self.common);
496
497        if self.task_status.is_some() {
498            JsonCodecHelper::encode_string_field(
499                &mut obj,
500                "task_status",
501                self.task_status.as_ref().unwrap(),
502            );
503        }
504        if self.range.is_some() {
505            JsonCodecHelper::encode_string_field(
506                &mut obj,
507                "offset",
508                &self.range.as_ref().unwrap().0,
509            );
510            JsonCodecHelper::encode_string_field(
511                &mut obj,
512                "length",
513                &self.range.as_ref().unwrap().1,
514            );
515        }
516        obj
517    }
518
519    fn decode_json(obj: &Map<String, Value>) -> BuckyResult<Self> {
520        let task_status = match obj.get("task_status") {
521            Some(task_status) => Some(JsonCodecHelper::decode_from_string(task_status)?),
522            None => None,
523        };
524
525        let offset = match obj.get("offset") {
526            Some(offset) => Some(JsonCodecHelper::decode_from_string(offset)?),
527            None => None,
528        };
529
530        let length = match obj.get("length") {
531            Some(length) => Some(JsonCodecHelper::decode_from_string(length)?),
532            None => None,
533        };
534
535        let range = if offset.is_some() && length.is_some() {
536            Some((offset.unwrap(), length.unwrap()))
537        } else {
538            None
539        };
540
541        Ok(Self {
542            common: JsonCodecHelper::decode_field(obj, "common")?,
543            task_status,
544            range,
545        })
546    }
547}
548
549impl ToString for TransTaskStatus {
550    fn to_string(&self) -> String {
551        match self {
552            TransTaskStatus::Stopped => "Stopped".to_string(),
553            TransTaskStatus::Failed => "Failed".to_string(),
554            TransTaskStatus::Running => "Running".to_string(),
555            TransTaskStatus::Finished => "Finished".to_string(),
556        }
557    }
558}
559
560impl FromStr for TransTaskStatus {
561    type Err = BuckyError;
562
563    fn from_str(s: &str) -> Result<Self, Self::Err> {
564        match s {
565            "Stopped" => Ok(TransTaskStatus::Stopped),
566            "Failed" => Ok(TransTaskStatus::Failed),
567            "Running" => Ok(TransTaskStatus::Running),
568            "Finished" => Ok(TransTaskStatus::Finished),
569            _ => {
570                let msg = format!("unknown TransTaskStatus {}", s);
571                error!("{}", msg.as_str());
572                Err(BuckyError::new(BuckyErrorCode::InvalidInput, msg))
573            }
574        }
575    }
576}
cyfs_lib/trans/request_codec.rs

cyfs_lib/trans/
request_codec.rs
