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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

use crate::types::primitive::Integer;
use serde::{de::Error, Deserialize, Deserializer};
use std::{error::Error as StdError, fmt};

/// API Response
#[derive(Clone, Debug)]
pub enum Response<T> {
    /// Success
    Success(T),
    /// Error
    Error(ResponseError),
}

impl<'de, T> Deserialize<'de> for Response<T>
where
    T: Deserialize<'de>,
{
    fn deserialize<D>(deserializer: D) -> Result<Response<T>, D::Error>
    where
        D: Deserializer<'de>,
    {
        let raw: RawResponse<T> = Deserialize::deserialize(deserializer)?;
        macro_rules! required {
            ($name:ident) => {{
                match raw.$name {
                    Some(val) => val,
                    None => return Err(D::Error::missing_field(stringify!($name))),
                }
            }};
        };
        Ok(if raw.ok {
            Response::Success(required!(result))
        } else {
            Response::Error(ResponseError {
                description: required!(description),
                error_code: raw.error_code,
                parameters: raw.parameters,
            })
        })
    }
}

/// Response error
#[derive(Clone, Debug)]
pub struct ResponseError {
    /// Human-readable description
    pub description: String,
    /// Error code
    pub error_code: Option<Integer>,
    /// Parameters
    pub parameters: Option<ResponseParameters>,
}

impl ResponseError {
    /// Whether request can be repeated
    pub fn can_retry(&self) -> bool {
        self.parameters.map(|x| x.retry_after.is_some()).unwrap_or(false)
    }
}

impl StdError for ResponseError {}

impl fmt::Display for ResponseError {
    fn fmt(&self, out: &mut fmt::Formatter) -> fmt::Result {
        write!(out, "a telegram error has occurred: description={}", self.description)?;
        if let Some(code) = self.error_code {
            write!(out, "; error_code={}", code)?;
        }
        if let Some(parameters) = self.parameters {
            if let Some(chat_id) = parameters.migrate_to_chat_id {
                write!(out, "; migrate_to_chat_id={}", chat_id)?;
            }
            if let Some(retry_after) = parameters.retry_after {
                write!(out, "; retry_after={}", retry_after)?;
            }
        }
        Ok(())
    }
}

/// Contains information about why a request was unsuccessful
#[derive(Clone, Copy, Debug, Deserialize)]
pub struct ResponseParameters {
    /// The group has been migrated to a supergroup with the specified identifier
    pub migrate_to_chat_id: Option<Integer>,
    /// In case of exceeding flood control,
    /// the number of seconds left to wait
    /// before the request can be repeated
    pub retry_after: Option<Integer>,
}

#[derive(Clone, Debug, Deserialize)]
struct RawResponse<T> {
    ok: bool,
    description: Option<String>,
    error_code: Option<Integer>,
    result: Option<T>,
    parameters: Option<ResponseParameters>,
}

#[cfg(test)]
mod tests {
    use super::*;
    use serde_json::json;

    #[derive(Clone, Debug, Deserialize)]
    struct Object {
        name: String,
    }

    #[test]
    fn deserialize() {
        let success: Response<Object> = serde_json::from_value(json!({
            "ok": true,
            "result": {"name": "test" }
        }))
        .unwrap();

        if let Response::Success(ref obj) = success {
            assert_eq!(obj.name, String::from("test"));
        } else {
            panic!("Unexpected response: {:?}", success);
        }

        let error: Response<Object> = serde_json::from_value(json!({
            "ok": false,
            "description": "test err",
            "error_code": 1,
            "parameters": {
                "migrate_to_chat_id": 2,
                "retry_after": 3
            }
        }))
        .unwrap();
        if let Response::Error(err) = error {
            assert_eq!(err.description, String::from("test err"));
            assert_eq!(err.error_code.unwrap(), 1);
            assert!(err.can_retry());
            let params = err.parameters.unwrap();
            assert_eq!(params.migrate_to_chat_id.unwrap(), 2);
            assert_eq!(params.retry_after.unwrap(), 3);
        } else {
            panic!("Unexpected response: {:?}", success);
        }

        let error: Response<Object> = serde_json::from_value(json!({
            "ok": false,
            "description": "test err"
        }))
        .unwrap();
        if let Response::Error(err) = error {
            assert_eq!(err.description, String::from("test err"));
            assert!(!err.can_retry());
            assert!(err.error_code.is_none());
            assert!(err.parameters.is_none());
        } else {
            panic!("Unexpected response: {:?}", success);
        }
    }
}