pixelast 0.1.0

A simple Pixela client.
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

use super::Authentication;
use super::endpoint;
use super::response;
use super::http_client::{HttpClient, RequestContext, MethodType};

use failure::Error;
use std::collections::HashMap;
use serde_json;

#[derive(Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CreateUserParam {
    pub token: String,
    pub username: String,
    pub agree_terms_of_service: ConsentAnswer,
    pub not_minor: ConsentAnswer,
}

/// Answer to the consent from. yes or no.
#[derive(Serialize, Deserialize)]
pub enum ConsentAnswer {
    #[serde(rename = "yes")]
    Yes,
    #[serde(rename = "no")]
    No,
}

pub(crate) fn create<T>(param: &CreateUserParam) -> Result<(), Error> where T: HttpClient {
    let uri = endpoint::users();
    let body = serde_json::to_string(param)?;
    let context = RequestContext::new(
        &uri,
        MethodType::Post,
        Some(&body),
        None,
    );

    let body = T::do_request(&context)?;
    response::build_result(&body)
}

pub(crate) fn update<T>(auth: &Authentication, new_token: &str) -> Result<(), Error> where T: HttpClient {
    let mut hash: HashMap<&str, &str> = HashMap::new();
    hash.insert("newToken", new_token);

    let uri = endpoint::user(&auth.username);
    let body = serde_json::to_string(&hash)?;
    let context = RequestContext::new(
        &uri,
        MethodType::Put,
        Some(&body),
        Some(&auth.token),
    );

    let body = T::do_request(&context)?;
    response::build_result(&body)
}

pub(crate) fn delete<T>(auth: &Authentication) -> Result<(), Error> where T: HttpClient {
    let uri = endpoint::user(&auth.username);
    let context = RequestContext::new(
        &uri,
        MethodType::Delete,
        None,
        Some(&auth.token),
    );

    let body = T::do_request(&context)?;
    response::build_result(&body)
}

#[cfg(test)]
mod user_test {
    use super::*;

    #[test]
    fn create_user_param_serialize_test() {
        let param = CreateUserParam {
            token: "testtoken".to_owned(),
            username: "testuser".to_owned(),
            agree_terms_of_service: ConsentAnswer::Yes,
            not_minor: ConsentAnswer::No,
        };

        let res = serde_json::to_string(&param);
        if let Ok(v) = res {
            assert_eq!(v, r#"{"token":"testtoken","username":"testuser","agreeTermsOfService":"yes","notMinor":"no"}"#);
        } else {
            panic!("failed serialize params");
        };
    }
}