vika_community 0.1.2

rust for vika api.
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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

use super::{Config, GetFieldsResp, Response, PostFieldReq, PostFieldResp};
use serde_json::Value;

use reqwest::blocking::Client;
use reqwest::header::{AUTHORIZATION, CONTENT_TYPE};

pub struct FieldsManager {
    pub config: Config,

    pub space_id: String,

    pub datasheet_id: String,

    pub view_id: String,
}

impl FieldsManager {
    pub fn new(config: Config, space_id: String, datasheet_id: String) -> FieldsManager {
        FieldsManager {
            config,
            space_id,
            datasheet_id,
            view_id: String::from(""),
        }
    }

    pub fn query_all(&self) -> Option<Vec<Value>> {
        let config: Config = self.config.clone();
        let url = format!(
            "{}://{}/fusion/{}/datasheets/{}/fields",
            &config.protocol, &config.host, &config.version, &self.datasheet_id
        );
        let client = Client::new();
        let request_builder = client.get(url).header(AUTHORIZATION, config.token.clone());
        let body;
        if !self.view_id.eq("") {
            body = request_builder
                .query(&[("viewId", self.view_id.as_str())])
                .send()
                .unwrap()
                .text()
                .unwrap();
        } else {
            body = request_builder.send().unwrap().text().unwrap();
        }
        let resp: Response<GetFieldsResp> = serde_json::from_str(&body).unwrap();
        if resp.code == 200 {
            Some(resp.data.fields)
        } else {
            None
        }
    }

    pub fn field_id(self, field_id: &String) -> FieldManager {
        FieldManager {
            config: self.config.clone(),
            space_id: self.space_id.clone(),
            datasheet_id: self.datasheet_id.clone(),
            field_id: field_id.clone(),
        }
    }

    pub fn post(&self, field: PostFieldReq) -> Option<PostFieldResp>{
        let config: Config = self.config.clone();
        let url = format!(
            "{}://{}/fusion/{}/spaces/{}/datasheets/{}/fields",
            &config.protocol, &config.host, &config.version, &self.space_id, &self.datasheet_id
        );
        let client = Client::new();
        let body = client
            .post(url)
            .header(AUTHORIZATION, config.token.clone())
            .header(CONTENT_TYPE, String::from("application/json"))
            .body(field.to_json_string())
            .send()
            .unwrap()
            .text()
            .unwrap();
            println!("{}", body);
        let resp: Response<PostFieldResp> = serde_json::from_str(&body).unwrap();
        if resp.code == 200 {
            Some(resp.data)
        } else {
            None
        }
    }
}

pub struct FieldManager {
    config: Config,

    space_id: String,

    datasheet_id: String,

    field_id: String,
}

impl FieldManager {

    pub fn delete(&self) -> bool {
        let config: Config = self.config.clone();
        let url = format!(
            "{}://{}/fusion/{}/spaces/{}/datasheets/{}/fields/{}",
            config.protocol,
            config.host,
            config.version,
            &self.space_id,
            &self.datasheet_id,
            &self.field_id
        );
        let client = Client::new();
        let body = client
            .delete(url)
            .header(AUTHORIZATION, config.token.clone())
            .header(CONTENT_TYPE, String::from("application/json"))
            .send()
            .unwrap()
            .text()
            .unwrap();
        let resp: Response<Value> = serde_json::from_str(&body).unwrap();
        if resp.code == 200 {
            true
        } else {
            false
        }
    }

}