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

use std::str::Utf8Error;
use std::string::FromUtf8Error;

use failure::Fail;
use reqwest;
use serde::{Deserialize, Serialize};

/// Error response from some APIs.
#[derive(Serialize, Deserialize, Debug, Clone, PartialOrd, PartialEq)]
pub struct ErrorResponse {
    /// Shows where this Json is from.
    pub command_type: String,
    /// Shows errors
    pub params: Errors,
}

/// Shows errors
#[derive(Serialize, Deserialize, Debug, Clone, PartialOrd, PartialEq)]
pub struct Errors {
    /// Shows errors
    pub errors: Vec<ErrorItem>,
}

/// Shows errors
#[derive(Serialize, Deserialize, Debug, Clone, PartialOrd, PartialEq)]
pub struct ErrorItem {
    /// Error kind
    pub field: String,
    /// Error detail message
    pub message: String,
}

/// Wrapper for reqwest::Error
#[derive(Debug)]
pub struct ReqwestError(pub reqwest::Error);

/// Enum of errors in this crate.
#[derive(Debug, Fail)]
pub enum Error {
    #[fail(display = "Some I/O Error: {:?}", error)]
    IOError { error: ::std::io::ErrorKind },
    #[fail(display = "Serde error")]
    Serde { error: serde_json::Error },
    #[fail(display = "Utf8Error: {:?}", error)]
    Utf8Error { error: ::std::str::Utf8Error },
    #[fail(display = "ReqwestError: {:?}", error)]
    ReqwestError { error: ReqwestError },
    #[fail(display = "AddrParseError: {:?}", error)]
    AddrParseError { error: std::net::AddrParseError },
    #[fail(display = "Utf8Error: {:?}", error)]
    MyError { error: String },
}

impl From<std::io::Error> for Error {
    fn from(error: std::io::Error) -> Self {
        Error::IOError {
            error: error.kind(),
        }
    }
}

impl From<Utf8Error> for Error {
    fn from(error: Utf8Error) -> Self {
        Error::Utf8Error { error: error }
    }
}

impl From<FromUtf8Error> for Error {
    fn from(error: FromUtf8Error) -> Self {
        Error::Utf8Error {
            error: error.utf8_error(),
        }
    }
}

impl From<&str> for Error {
    fn from(error: &str) -> Self {
        Error::MyError {
            error: error.to_string(),
        }
    }
}

impl From<String> for Error {
    fn from(error: String) -> Self {
        Error::MyError { error: error }
    }
}

impl From<reqwest::Error> for Error {
    fn from(error: reqwest::Error) -> Self {
        Error::ReqwestError {
            error: ReqwestError(error),
        }
    }
}

impl From<ReqwestError> for Error {
    fn from(error: ReqwestError) -> Self {
        Error::ReqwestError { error: error }
    }
}

impl PartialEq for ReqwestError {
    fn eq(&self, other: &ReqwestError) -> bool {
        self.0.to_string() == other.0.to_string()
    }
}

impl From<serde_json::Error> for Error {
    fn from(error: serde_json::Error) -> Error {
        Error::Serde { error: error }
    }
}

impl From<std::net::AddrParseError> for Error {
    fn from(error: std::net::AddrParseError) -> Error {
        Error::AddrParseError { error: error }
    }
}

impl Error {
    /// Create error message
    #[allow(dead_code)]
    pub fn create_myerror(message: &str) -> Error {
        Error::MyError {
            error: message.to_string(),
        }
        .into()
    }
}