libedgegrid 0.1.0

This library implements an Authentication handler for the Akamai OPEN EdgeGrid Authentication scheme in Rust
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

//! Events API
use curl;
use auth::EdgeGridAuth;
use request::HttpRequestVerb::*;
use url::percent_encoding as pe;
use rustc_serialize::json;
use std::borrow::Borrow;

#[derive(Debug, RustcDecodable)]
#[allow(non_snake_case)]
pub struct Filter {
    endRange: Option<usize>,
    startRange: Option<usize>,
}

#[derive(Debug, RustcDecodable)]
#[allow(non_snake_case)]
pub struct Contents {
    resultsPerPage: Option<usize>,
    currentPage: Option<usize>,
    totalResultsCount: Option<usize>,
    totalPageCount: Option<usize>,
    sortKey: Option<String>,
    sortOrder: Option<String>,
    filters: Option<Filter>,
}

#[derive(Debug, RustcDecodable)]
#[allow(non_snake_case)]
pub struct Customer {
    accountID: Option<String>,
    accountName: Option<String>,
    supportLevel: Option<String>,
}

#[derive(Debug, RustcDecodable)]
#[allow(non_snake_case)]
pub struct Tag {
    id: Option<usize>,
    name: Option<String>,
    global: Option<bool>,
}

#[derive(Debug, RustcDecodable)]
#[allow(non_snake_case)]
pub struct DataSet {
    id: Option<usize>,
    customerEventId: Option<String>,
    version: Option<usize>,
    name: Option<String>,
    description: Option<String>,
    eventType: Option<String>,
    customer: Option<Customer>,
    start: Option<usize>,
    end: Option<usize>,
    createdDate: Option<usize>,
    createdBy: Option<String>,
    modifiedDate: Option<usize>,
    modifiedBy: Option<String>,
    audienceSize: Option<usize>,
    audienceLocations: Option<Vec<String>>,
    coordinators: Option<Vec<String>>,
    locked: Option<bool>,
    tags: Option<Vec<Tag>>,
    services: Option<String>,
    supportType: Option<String>,
}

#[derive(Debug, RustcDecodable)]
#[allow(non_snake_case)]
pub struct EventsResponse {
    status: Option<String>,
    contents: Option<Contents>,
    dataSet: Option<Vec<DataSet>>,
}

pub fn get_by_account_id(
    egr: &EdgeGridAuth,
    account_id: &str
) -> Result<EventsResponse, ::ApiError> {
    let mut url = String::from(egr.baseurl());
    let relurl = format!("/events/v2/{}/events", account_id);

    url.push_str(&relurl[..]);
    url = pe::utf8_percent_encode(&url[..], pe::QUERY_ENCODE_SET);
    let header = try!(egr.auth_header(GET, &relurl[..], None));
    debug!("URL: {}", url);
    let resp = try!(curl::http::handle()
        .timeout(egr.timeout())
        .get(&url[..])
        .header("Content-Type", "application/json")
        .header("Authorization", &header[..])
        .exec()
    );
    let body = String::from_utf8_lossy(resp.get_body());
    debug!("Status: {}", resp.get_code());
    debug!("Body: {}", body);

    match resp.get_code() {
        200 => {
            let jsonresp: EventsResponse = try!(json::decode(&body));
            Ok(jsonresp)
        },
        _   => {
            let json_err: ::JSONError = try!(json::decode(&body));
            Err(::ApiError{
                json_err: json_err,
                body: String::from(body.borrow())
            })
        }
    }
}