kutt 0.0.2

command line tool for kutt.it service
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

use crate::constants::*;
use crate::errors::{Error, Result};
use crate::utils::get_id_from_link;
use reqwest::Client;

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct ListLinks {
    pub list: Vec<Link>,
    #[serde(rename = "countAll")]
    pub count_all: u32,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct Link {
    count: u32,
    #[serde(rename = "createdAt")]
    created_at: String,
    id: String,
    target: String,
    password: bool,
    #[serde(rename = "shortUrl")]
    short_url: String,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct Kutt {
    target: String,
    customurl: Option<String>,
    password: Option<String>,
    reuse: bool,
}

impl Kutt {
    pub fn target_url(target: &str) -> Self {
        Kutt {
            target: target.to_owned(),
            customurl: None,
            password: None,
            reuse: false,
        }
    }
    pub fn custom_url<S: Into<String>>(mut self, customurl: S) -> Self {
        self.customurl = Some(customurl.into());
        self
    }
    pub fn password<S: Into<String>>(mut self, password: S) -> Self {
        self.password = Some(password.into());
        self
    }
    pub fn reuse(mut self) -> Self {
        self.reuse = true;
        self
    }

    pub fn create_short_link(&self) -> Result<String> {
        #[derive(Debug, Serialize, Deserialize)]
        pub struct Response {
            #[serde(rename = "createdAt")]
            created_at: String,
            id: String,
            target: String,
            password: bool,
            #[serde(rename = "shortUrl")]
            short_url: String,
        }
        let request = serde_json::to_string(self).unwrap();
        let response: Response = Client::new()
            .post(&format!("{}/{}", BASE_URL, "api/url/submit"))
            .header("X-API-Key", &*KUTT_API_KEY.as_str())
            .header("Content-Type", "application/json")
            .body(request)
            .send()
            .map_err(|e| {
                eprintln!("{}", e);
                Error::SendRequsetError
            })?
            .json()
            .map_err(|e| {
                eprintln!("{}", e);
                Error::ParseJsonError
            })?;
        Ok(response.short_url)
    }
    pub fn delete_link(short_link: &str) -> Result {
        let body = match get_id_from_link(short_link) {
            Ok(id) => r#"{"id":""#.to_owned() + id.as_str() + r#"","domain":null}"#,
            Err(e) => return Err(e),
        };
        let resp: reqwest::Response = Client::new()
            .post(&format!("{}/{}", BASE_URL, "api/url/deleteurl"))
            .header("X-API-Key", &*KUTT_API_KEY.as_str())
            .header("Content-Type", "application/json")
            .body(body.clone())
            .send()
            .map_err(|e| {
                eprintln!("{}", e);
                Error::SendRequsetError
            })?;
        if resp.status() == 200 {
            Ok(())
        } else {
            Err(Error::UnsuccessResponseError)
        }
    }
    #[allow(dead_code)]
    pub fn list_links() -> Result<ListLinks> {
        let resp: ListLinks = Client::new()
            .get(&format!("{}/{}", BASE_URL, "api/url/geturls"))
            .header("X-API-Key", &*KUTT_API_KEY.as_str())
            .send()
            .map_err(|e| {
                eprintln!("{}", e);
                Error::SendRequsetError
            })?
            .json()
            .map_err(|e| {
                eprintln!("{}", e);
                Error::ParseJsonError
            })?;
        Ok(resp)
    }
}