mtgapi-client 0.2.0

API bindings for www.magicthegathering.io
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

use crate::api::error::MtgApiErrorKind;
use failure::Error;
use failure::ResultExt;
use crate::model::card::CardDetail;
use crate::model::set::SetDetail;
use reqwest::Client;
use reqwest::Response;
use serde_json;
use std::rc::Weak;

pub(crate) async fn send_response(url: &str, client: &Weak<Client>) -> Result<Response, Error> {
    let client = match client.upgrade() {
        Some(client) => Ok(client),
        None => Err(MtgApiErrorKind::ClientDropped),
    }?;
    info!("GET; {}", &url);
    Ok(client.get(url).send().await?)
}

pub(crate) fn retrieve_cards_from_body(body: &str) -> Result<Vec<CardDetail>, Error> {
    use crate::model::card::CardsDto;
    match serde_json::from_str::<CardsDto>(&body).context(MtgApiErrorKind::CardBodyParseError)? {
        CardsDto::Cards { cards } => Ok(cards),
        CardsDto::Error { error, status } => match status {
            Some(status) => Err(MtgApiErrorKind::ApiError {
                cause: format!("{}: {}", status, error),
            }.into()),
            None => Err(MtgApiErrorKind::ApiError { cause: error }.into()),
        },
    }
}

pub(crate) fn retrieve_card_from_body(body: &str) -> Result<Box<CardDetail>, Error> {
    use crate::model::card::CardDto;
    match serde_json::from_str::<CardDto>(&body).context(MtgApiErrorKind::CardBodyParseError)? {
        CardDto::Card { card } => Ok(card),
        CardDto::Error { error, status } => match status {
            Some(status) => Err(MtgApiErrorKind::ApiError {
                cause: format!("{}: {}", status, error),
            }.into()),
            None => Err(MtgApiErrorKind::ApiError { cause: error }.into()),
        },
    }
}

pub(crate) fn retrieve_sets_from_body(body: &str) -> Result<Vec<SetDetail>, Error> {
    use crate::model::set::SetsDto;
    match serde_json::from_str::<SetsDto>(&body).context(MtgApiErrorKind::SetBodyParseError)? {
        SetsDto::Sets { sets } => Ok(sets),
        SetsDto::Error { error, status } => match status {
            Some(status) => Err(MtgApiErrorKind::ApiError {
                cause: format!("{}: {}", status, error),
            }.into()),
            None => Err(MtgApiErrorKind::ApiError { cause: error }.into()),
        },
    }
}

pub(crate) fn retrieve_set_from_body(body: &str) -> Result<Box<SetDetail>, Error> {
    use crate::model::set::SetDto;
    match serde_json::from_str::<SetDto>(&body).context(MtgApiErrorKind::SetBodyParseError)? {
        SetDto::Set { set } => Ok(set),
        SetDto::Error { error, status } => match status {
            Some(status) => Err(MtgApiErrorKind::ApiError {
                cause: format!("{}: {}", status, error),
            }.into()),
            None => Err(MtgApiErrorKind::ApiError { cause: error }.into()),
        },
    }
}

pub(crate) fn retrieve_formats_from_body(body: &str) -> Result<Vec<String>, Error> {
    use crate::model::format::FormatDto;
    match serde_json::from_str::<FormatDto>(&body).context(MtgApiErrorKind::FormatBodyParseError)? {
        FormatDto::Formats { formats } => Ok(formats),
        FormatDto::Error { error, status } => match status {
            Some(status) => Err(MtgApiErrorKind::ApiError {
                cause: format!("{}: {}", status, error),
            }.into()),
            None => Err(MtgApiErrorKind::ApiError { cause: error }.into()),
        },
    }
}

pub(crate) fn retrieve_types_from_body(body: &str) -> Result<Vec<String>, Error> {
    use crate::model::types::TypesDto;
    match serde_json::from_str::<TypesDto>(&body).context(MtgApiErrorKind::TypeBodyParseError)? {
        TypesDto::Types { types } => Ok(types),
        TypesDto::Error { error, status } => match status {
            Some(status) => Err(MtgApiErrorKind::ApiError {
                cause: format!("{}: {}", status, error),
            }.into()),
            None => Err(MtgApiErrorKind::ApiError { cause: error }.into()),
        },
    }
}

pub(crate) fn retrieve_subtypes_from_body(body: &str) -> Result<Vec<String>, Error> {
    use crate::model::types::SubtypesDto;
    match serde_json::from_str::<SubtypesDto>(&body).context(MtgApiErrorKind::TypeBodyParseError)? {
        SubtypesDto::Subtypes { subtypes } => Ok(subtypes),
        SubtypesDto::Error { error, status } => match status {
            Some(status) => Err(MtgApiErrorKind::ApiError {
                cause: format!("{}: {}", status, error),
            }.into()),
            None => Err(MtgApiErrorKind::ApiError { cause: error }.into()),
        },
    }
}

pub(crate) fn retrieve_supertypes_from_body(body: &str) -> Result<Vec<String>, Error> {
    use crate::model::types::SupertypesDto;
    match serde_json::from_str::<SupertypesDto>(&body).context(MtgApiErrorKind::TypeBodyParseError)?
    {
        SupertypesDto::Supertypes { supertypes } => Ok(supertypes),
        SupertypesDto::Error { error, status } => match status {
            Some(status) => Err(MtgApiErrorKind::ApiError {
                cause: format!("{}: {}", status, error),
            }.into()),
            None => Err(MtgApiErrorKind::ApiError { cause: error }.into()),
        },
    }
}