Updated API to the latest server version

src/error.rs

@@ -8,7 +8,7 @@ use std::error::Error as StdError;
 
 use hyper::error::Error as HyperError;
 use rustc_serialize::json;
-use dto::{FromDTOError, ResponseDTO};
+use dto::FromDTOError;
 
 /// The result type of the API.
 pub type Result<T> = StdResult<T, Error>;
@@ -24,12 +24,16 @@ pub enum Error {
     FromDTOError(FromDTOError),
     /// JSON decode error.
     JSONDecodeError(json::DecoderError),
+    /// Forbidden.
+    Forbidden(String),
+    /// Bad request
+    BadRequest(String),
     /// Error Logging in
-    ClientError(ResponseDTO),
-    /// Unauthorized.
-    Unauthorized,
+    ClientError(String),
+    /// Not found
+    NotFound(String),
     /// Internal server error.
-    ServerError,
+    ServerError(String),
     /// The token type is not valid.
     InvalidTokenType,
     /// The scope is not valid.
@@ -81,15 +85,17 @@ impl StdError for Error {
             Error::IO(ref e) => e.description(),
             Error::FromDTOError(ref e) => e.description(),
             Error::JSONDecodeError(ref e) => e.description(),
-            Error::ClientError(ref e) => &e.message,
-            Error::TransactionError => "Error Generating Transaction",
-            Error::RegistrationError => "Error Registering User",
-            Error::Unauthorized => "the provided token is not authorized to use the method",
-            Error::ServerError => "a server error occurred",
+            Error::Forbidden(ref e) => e,
+            Error::BadRequest(ref e) => e,
+            Error::ClientError(ref e) => e,
+            Error::NotFound(ref e) => e,
+            Error::ServerError(ref e) => e,
+            Error::TransactionError => "error generating transaction",
+            Error::RegistrationError => "error registering user",
             Error::InvalidTokenType => "the provided token type is not a valid token type",
             Error::InvalidScope => "the provided scope is not a valid scope",
             Error::InvalidSecret => "the provided secret is not a valid secret",
-            Error::ConfirmConnectionError => "Error trying to confirm connection",
+            Error::ConfirmConnectionError => "error trying to confirm connection",
         }
     }
 

src/v1/friends.rs

@@ -2,11 +2,10 @@ use std::io::Read;
 
 use hyper::method::Method;
 use hyper::header::{Headers, Authorization};
-use hyper::status::StatusCode;
 use rustc_serialize::json;
 
 use dto::{FromDTO, ScopeDTO as Scope, PendingFriendRequestDTO, FriendRequestDTO,
-          ConfirmFriendRequestDTO, ResponseDTO, RelationshipDTO as Relationship};
+          ConfirmFriendRequestDTO, RelationshipDTO as Relationship};
 
 use error::{Result, Error};
 use super::{Client, VoidDTO};
@@ -41,28 +40,13 @@ impl Client {
                     None => None,
                 },
             };
-            let mut response = try!(self.send_request(Method::Post,
-                                                      format!("{}create_friend_request",
-                                                              self.url),
-                                                      headers,
-                                                      Some(&dto)));
-
-            match response.status {
-                StatusCode::Ok => Ok(()),
-                StatusCode::Unauthorized => Err(Error::Unauthorized),
-                StatusCode::Accepted => {
-                    let mut response_str = String::new();
-                    let _ = try!(response.read_to_string(&mut response_str));
-                    match json::decode::<ResponseDTO>(&response_str) {
-                        Ok(r) => Err(Error::ClientError(r)),
-                        Err(e) => Err(e.into()),
-                    }
-
-                }
-                _ => Err(Error::ServerError),
-            }
+            let _ = try!(self.send_request(Method::Post,
+                                           format!("{}create_friend_request", self.url),
+                                           headers,
+                                           Some(&dto)));
+            Ok(())
         } else {
-            Err(Error::Unauthorized)
+            Err(Error::Forbidden(String::from("the token must be an unexpired user token")))
         }
     }
 
@@ -86,33 +70,15 @@ impl Client {
                 }),
                 id: connection_id,
             };
-            let mut response = try!(self.send_request(Method::Post,
-                                                      format!("{}confirm_friend_request",
+            let _ = try!(self.send_request(Method::Post,
+                                           format!("{}confirm_friend_request",
                                    self.url,
                                   ),
-                                                      headers,
-                                                      Some(&dto)));
-
-            match response.status {
-                StatusCode::Ok => Ok(()),
-                StatusCode::Unauthorized => {
-                    let mut response_str = String::new();
-                    let _ = try!(response.read_to_string(&mut response_str));
-                    Err(Error::Unauthorized)
-                }
-                StatusCode::Accepted => {
-                    let mut response_str = String::new();
-                    let _ = try!(response.read_to_string(&mut response_str));
-                    match json::decode::<ResponseDTO>(&response_str) {
-                        Ok(r) => Err(Error::ClientError(r)),
-                        Err(e) => Err(e.into()),
-                    }
-
-                }
-                _ => Err(Error::ServerError),
-            }
+                                           headers,
+                                           Some(&dto)));
+            Ok(())
         } else {
-            Err(Error::Unauthorized)
+            Err(Error::Forbidden(String::from("the token must be an unexpired user token")))
         }
     }
 
@@ -133,21 +99,16 @@ impl Client {
                                        format!("{}friend_requests/{}", self.url, user_id),
                                        headers,
                                        None::<&VoidDTO>));
-            match response.status {
-                StatusCode::Ok => {
-                    let mut response_str = String::new();
-                    let _ = try!(response.read_to_string(&mut response_str));
-                    let connections: Vec<PendingFriendRequestDTO> =
-                        try!(json::decode(&response_str));
-                    Ok(connections.into_iter()
-                        .map(|t| PendingFriendRequest::from_dto(t).unwrap())
-                        .collect())
-                }
-                StatusCode::Unauthorized => Err(Error::Unauthorized),
-                _ => Err(Error::ServerError),
-            }
+            let mut response_str = String::new();
+            let _ = try!(response.read_to_string(&mut response_str));
+            let connections: Vec<PendingFriendRequestDTO> = try!(json::decode(&response_str));
+            Ok(connections.into_iter()
+                .map(|t| PendingFriendRequest::from_dto(t).unwrap())
+                .collect())
         } else {
-            Err(Error::Unauthorized)
+            Err(Error::Forbidden(String::from("the token must be an unexpired user or admin \
+                                               token, and in the case of an user token, the ID \
+                                               in the token must be the same as the given ID")))
         }
     }
 }

src/v1/mod.rs

@@ -1,15 +1,16 @@
 //! First version of the Fractal Global Credits API.
 
-use std::result::Result;
+use std::io::Read;
 
 use hyper::Client as HyperClient;
-use hyper::error::Error as HyperError;
-use hyper::header::Headers;
+use hyper::header::{Headers, Accept, qitem};
+use hyper::status::StatusCode;
+use hyper::mime::{Mime, TopLevel, SubLevel, Attr, Value};
 use hyper::method::Method;
 use hyper::client::response::Response;
 
 use rustc_serialize::json;
-use dto::DTO;
+use dto::{DTO, ResponseDTO};
 
 /// Fractal API server.
 pub const FRACTAL_SERVER: &'static str = "https://api.fractal.global/";
@@ -24,6 +25,8 @@ mod user;
 mod friends;
 mod transaction;
 
+use error::{Result, Error};
+
 /// The client struct.
 ///
 /// This struct will be in charge of connections to the Fractal Global Credits API.
@@ -40,10 +43,13 @@ impl Client {
     fn send_request<S: AsRef<str>, D: DTO>(&self,
                                            method: Method,
                                            url: S,
-                                           headers: Headers,
+                                           mut headers: Headers,
                                            dto: Option<&D>)
-                                           -> Result<Response, HyperError> {
+                                           -> Result<Response> {
 
+        headers.set(Accept(vec![qitem(Mime(TopLevel::Application,
+                                           SubLevel::Json,
+                                           vec![(Attr::Charset, Value::Utf8)]))]));
         let body = match dto {
             Some(d) => Some(json::encode(d).unwrap()),
             None => None,
@@ -55,7 +61,7 @@ impl Client {
             response = response.body(b);
         }
         let response = response.send();
-        if response.is_err() {
+        let mut response = try!(if response.is_err() {
             let mut response = self.client
                 .request(method, url.as_ref())
                 .headers(headers.clone());
@@ -65,6 +71,37 @@ impl Client {
             response.send()
         } else {
             response
+        });
+
+        match response.status {
+            StatusCode::Ok => Ok(response),
+            status => {
+                let mut response_str = String::new();
+                let _ = try!(response.read_to_string(&mut response_str));
+
+                match status {
+                    StatusCode::Forbidden => {
+                        let response_dto: ResponseDTO = try!(json::decode(&response_str));
+                        Err(Error::Forbidden(response_dto.message))
+                    }
+                    StatusCode::Accepted => {
+                        let response_dto: ResponseDTO = try!(json::decode(&response_str));
+                        Err(Error::ClientError(response_dto.message))
+                    }
+                    StatusCode::BadRequest => {
+                        let response_dto: ResponseDTO = try!(json::decode(&response_str));
+                        Err(Error::BadRequest(response_dto.message))
+                    }
+                    StatusCode::NotFound => {
+                        let response_dto: ResponseDTO = try!(json::decode(&response_str));
+                        Err(Error::NotFound(response_dto.message))
+                    }
+                    _ => {
+                        let response_dto: ResponseDTO = try!(json::decode(&response_str));
+                        Err(Error::ServerError(response_dto.message))
+                    }
+                }
+            }
         }
     }
 }

src/v1/oauth.rs

@@ -7,9 +7,7 @@ use std::io::Read;
 
 use hyper::header::Bearer;
 use hyper::method::Method;
-use hyper::header::{Headers, Authorization, Basic, Accept, qitem};
-use hyper::mime::{Mime, TopLevel, SubLevel, Attr, Value};
-use hyper::status::StatusCode;
+use hyper::header::{Headers, Authorization, Basic};
 
 use chrono::{Duration, UTC, DateTime};
 use rustc_serialize::json;
@@ -102,28 +100,17 @@ impl Client {
             Ok(b) => {
                 if b.len() == SECRET_LEN {
                     let mut headers = Headers::new();
-                    headers.set(Accept(vec![
-                            qitem(Mime(TopLevel::Application, SubLevel::Json,
-                                       vec![(Attr::Charset, Value::Utf8)])),
-                        ]));
                     headers.set(Authorization(Basic {
                         username: String::from(app_id.as_ref()),
                         password: Some(String::from(secret.as_ref())),
                     }));
-                    let mut response = try!(self.send_request(Method::Post,
+                    let mut response = try!(self.send_request(Method::Get,
                                                               format!("{}token", self.url),
                                                               headers,
                                                               None::<&VoidDTO>));
-
-                    match response.status {
-                        StatusCode::Ok => {
-                            let mut response_str = String::new();
-                            let _ = try!(response.read_to_string(&mut response_str));
-                            Ok(try!(AccessToken::from_dto(try!(json::decode(&response_str)))))
-                        }
-                        StatusCode::Unauthorized => Err(Error::Unauthorized),
-                        _ => Err(Error::ServerError),
-                    }
+                    let mut response_str = String::new();
+                    let _ = try!(response.read_to_string(&mut response_str));
+                    Ok(try!(AccessToken::from_dto(try!(json::decode(&response_str)))))
                 } else {
                     Err(Error::InvalidSecret)
                 }
@@ -156,18 +143,12 @@ impl Client {
                                                       format!("{}create_client", self.url),
                                                       headers,
                                                       Some(&dto)));
-            match response.status {
-                StatusCode::Ok => {
-                    let mut response_str = String::new();
-                    let _ = try!(response.read_to_string(&mut response_str));
-                    let dto_client: ClientInfoDTO = try!(json::decode(&response_str));
-                    Ok(try!(ClientInfo::from_dto(dto_client)))
-                }
-                StatusCode::Unauthorized => Err(Error::Unauthorized),
-                _ => Err(Error::ServerError),
-            }
+            let mut response_str = String::new();
+            let _ = try!(response.read_to_string(&mut response_str));
+            let client_dto: ClientInfoDTO = try!(json::decode(&response_str));
+            Ok(try!(ClientInfo::from_dto(client_dto)))
         } else {
-            Err(Error::Unauthorized)
+            Err(Error::Forbidden(String::from("the token must be an unexpired admin token")))
         }
     }
 }