weeb_api 0.2.0

//! Bridge to provide a client implementation for the `reqwest` crate.
//!
//! # Examples
//!
//! Refer to the documentation for [`WeebApiRequester`].
//!
//! [`WeebApiRequester`]: trait.WeebApiRequester.html

use std::io::{Cursor, Read};
use reqwest::header::Authorization;
use reqwest::multipart::{Form, Part};
use reqwest::{Client as ReqwestClient, RequestBuilder, StatusCode, Url};
use serde::de::DeserializeOwned;
use serde_json;
use ::model::{
    ApiResponse,
    Image,
    ImageTagsResponse,
    ImageTypesResponse,
    ImageUploadResponse
};
use ::{Error, ImageParams, Result, UploadParams, constants};

/// Trait which defines the methods necessary to interact with the service.
///
/// # Examples
///
/// To bring in the implemenation for the `reqwest` Client, simply use the
/// trait:
///
/// ```rust,no_run
/// use weeb_api::WeebApiReqwestRequester;
/// ```
///
/// At this point, the methods will be on your Reqwest Client.
pub trait WeebApiRequester {
    /// Retrieves information about the API.
    ///
    /// # Examples
    ///
    /// Get basic info about the API:
    ///
    /// ```rust,no_run
    /// extern crate reqwest;
    /// extern crate weeb_api;
    /// # use std::error::Error;
    /// #
    /// # fn try_main() -> Result<(), Box<Error>> {
    /// #
    /// use reqwest::Client;
    /// use std::env;
    /// use weeb_api::WeebApiReqwestRequester;
    ///
    /// let token = env::var("WEEB_TOKEN")?;
    ///
    /// let client = Client::new();
    ///
    /// let response = client.get_images()?;
    ///
    /// println!("Info: {:?}", response);
    /// #     Ok(())
    /// # }
    /// #
    /// # fn main() {
    /// #     try_main().unwrap();
    /// # }
    /// ```
    ///
    /// # Errors
    ///
    /// Returns [`Error::Json`] if there was an error parsing the response
    /// body.
    ///
    /// Returns [`Error::ReqwestBad`] if the request was otherwise bad for some
    /// reason, containing the response.
    ///
    /// Returns [`Error::ReqwestInvalid`] if the response was a non-OK (status
    /// code 200) response, containing the response.
    ///
    /// [`Error::Json`]: ../enum.Error.html#variant.Json
    /// [`Error::ReqwestBad`]: ../enum.Error.html#variant.ReqwestBad
    /// [`Error::ReqwestInvalid`]: ../enum.Error.html#variant.ReqwestInvalid
    fn get_images(&self) -> Result<ApiResponse>;

    /// Get info on an image.
    ///
    /// # Examples
    ///
    /// Get info about the image with the id "ryh6x04Rb":
    ///
    /// ```rust,no_run
    /// extern crate reqwest;
    /// extern crate weeb_api;
    /// # use std::error::Error;
    /// #
    /// # fn try_main() -> Result<(), Box<Error>> {
    /// #
    /// use reqwest::Client;
    /// use std::env;
    /// use weeb_api::WeebApiReqwestRequester;
    ///
    /// let token = env::var("WEEB_TOKEN")?;
    ///
    /// let client = Client::new();
    ///
    /// let id = "ryh6x04Rb";
    /// let response = client.get_image_info(token, id)?;
    ///
    /// println!("Info: {:?}", response);
    /// #     Ok(())
    /// # }
    /// #
    /// # fn main() {
    /// #     try_main().unwrap();
    /// # }
    /// ```
    ///
    /// # Errors
    ///
    /// Returns [`Error::Json`] if there was an error parsing the response
    /// body.
    ///
    /// Returns [`Error::ReqwestBad`] if the request was otherwise bad for some
    /// reason, containing the response.
    ///
    /// Returns [`Error::ReqwestInvalid`] if the response was a non-OK (status
    /// code 200) response, containing the response.
    ///
    /// Returns [`Error::ReqwestUnauthorized`] if the authorization token was
    /// invalid.
    ///
    /// [`Error::Json`]: ../enum.Error.html#variant.Json
    /// [`Error::ReqwestBad`]: ../enum.Error.html#variant.ReqwestBad
    /// [`Error::ReqwestInvalid`]: ../enum.Error.html#variant.ReqwestInvalid
    /// [`Error::ReqwestUnauthorized`]: ../enum.Error.html#variant.ReqwestUnauthorized
    fn get_image_info<S>(&self, auth: S, id: &str) -> Result<Image>
        where S: Into<String>;

    /// Retrieves a random image given the matching parameters.
    ///
    /// **Note**: You must specify at least one of [`kind`] or [`tags`] in the
    /// image params.
    ///
    /// # Examples
    ///
    /// Retrieve a random image with the "sleepy" kind:
    ///
    /// ```rust,no_run
    /// extern crate reqwest;
    /// extern crate weeb_api;
    /// # use std::error::Error;
    /// #
    /// # fn try_main() -> Result<(), Box<Error>> {
    /// #
    /// use reqwest::Client;
    /// use std::env;
    /// use weeb_api::{ImageParams, WeebApiReqwestRequester};
    ///
    /// let token = env::var("WEEB_TOKEN")?;
    ///
    /// let client = Client::new();
    ///
    /// let params = ImageParams::kind("sleepy");
    /// let response = client.get_image_random(token, params)?;
    ///
    /// println!("URL: {}", response.url);
    /// #     Ok(())
    /// # }
    /// #
    /// # fn main() {
    /// #     try_main().unwrap();
    /// # }
    /// ```
    ///
    /// Retrieve a random image with the "girl" tag:
    ///
    /// ```rust,no_run
    /// extern crate reqwest;
    /// extern crate weeb_api;
    /// # use std::error::Error;
    /// #
    /// # fn try_main() -> Result<(), Box<Error>> {
    /// #
    /// use reqwest::Client;
    /// use std::env;
    /// use weeb_api::{ImageParams, WeebApiReqwestRequester};
    ///
    /// let token = env::var("WEEB_TOKEN")?;
    ///
    /// let client = Client::new();
    ///
    /// let params = ImageParams::tags(vec!["girl"]);
    /// let response = client.get_image_random(token, params)?;
    ///
    /// println!("URL: {}", response.url);
    /// #     Ok(())
    /// # }
    /// #
    /// # fn main() {
    /// #     try_main().unwrap();
    /// # }
    /// ```
    ///
    /// # Errors
    ///
    /// Returns [`Error::Json`] if there was an error parsing the response
    /// body.
    ///
    /// Returns [`Error::NoParamsSpecified`] if the input did not specify one of
    /// the required image parameters, containing the image parameters.
    ///
    /// Returns [`Error::ReqwestBad`] if the request was otherwise bad for some
    /// reason, containing the response.
    ///
    /// Returns [`Error::ReqwestInvalid`] if the response was a non-OK (status
    /// code 200) response, containing the response.
    ///
    /// Returns [`Error::ReqwestParse`] if there was an error parsing the image
    /// parameters into a valid URL.
    ///
    /// Returns [`Error::ReqwestUnauthorized`] if the authorization token was
    /// invalid.
    ///
    /// [`Error::Json`]: ../enum.Error.html#variant.Json
    /// [`Error::NoParamsSpecified`]: ../enum.Error.html#variant.NoParamsSpecified
    /// [`Error::ReqwestBad`]: ../enum.Error.html#variant.ReqwestBad
    /// [`Error::ReqwestInvalid`]: ../enum.Error.html#variant.ReqwestInvalid
    /// [`Error::ReqwestParse`]: ../enum.Error.html#variant.ReqwestParse
    /// [`Error::ReqwestUnauthorized`]: ../enum.Error.html#variant.ReqwestUnauthorized
    fn get_image_random<S>(&self, auth: S, params: ImageParams) ->
        Result<Image> where S: Into<String>;

    /// Retrieves all the current image tags.
    ///
    /// # Examples
    ///
    /// Retrieve all image tags including hidden ones:
    ///
    /// ```rust,no_run
    /// extern crate reqwest;
    /// extern crate weeb_api;
    /// # use std::error::Error;
    /// #
    /// # fn try_main() -> Result<(), Box<Error>> {
    /// #
    /// use reqwest::Client;
    /// use std::env;
    /// use weeb_api::WeebApiReqwestRequester;
    ///
    /// let token = env::var("WEEB_TOKEN")?;
    ///
    /// let client = Client::new();
    ///
    /// let response = client.get_image_tags(token, true)?;
    ///
    /// println!("Tags: {:?}", response);
    /// #     Ok(())
    /// # }
    /// #
    /// # fn main() {
    /// #     try_main().unwrap();
    /// # }
    /// ```
    ///
    /// # Errors
    ///
    /// Returns [`Error::Json`] if there was an error parsing the response
    /// body.
    ///
    /// Returns [`Error::ReqwestBad`] if the request was otherwise bad for some
    /// reason, containing the response.
    ///
    /// Returns [`Error::ReqwestInvalid`] if the response was a non-OK (status
    /// code 200) response, containing the response.
    ///
    /// Returns [`Error::ReqwestUnauthorized`] if the authorization token was
    /// invalid.
    ///
    /// [`Error::Json`]: ../enum.Error.html#variant.Json
    /// [`Error::ReqwestBad`]: ../enum.Error.html#variant.ReqwestBad
    /// [`Error::ReqwestInvalid`]: ../enum.Error.html#variant.ReqwestInvalid
    /// [`Error::ReqwestUnauthorized`]: ../enum.Error.html#variant.ReqwestUnauthorized
    fn get_image_tags<S>(&self, auth: S, hidden: bool) -> Result<Vec<String>>
        where S: Into<String>;

    /// Retrieves all the current image types.
    ///
    /// # Examples
    ///
    /// Retrieve all image tags including hidden ones:
    ///
    /// ```rust,no_run
    /// extern crate reqwest;
    /// extern crate weeb_api;
    /// # use std::error::Error;
    /// #
    /// # fn try_main() -> Result<(), Box<Error>> {
    /// #
    /// use reqwest::Client;
    /// use std::env;
    /// use weeb_api::WeebApiReqwestRequester;
    ///
    /// let token = env::var("WEEB_TOKEN")?;
    ///
    /// let client = Client::new();
    ///
    /// let response = client.get_image_types(token, true)?;
    ///
    /// println!("Types: {:?}", response);
    /// #     Ok(())
    /// # }
    /// #
    /// # fn main() {
    /// #     try_main().unwrap();
    /// # }
    /// ```
    ///
    /// # Errors
    ///
    /// Returns [`Error::Json`] if there was an error parsing the response
    /// body.
    ///
    /// Returns [`Error::ReqwestBad`] if the request was otherwise bad for some
    /// reason, containing the response.
    ///
    /// Returns [`Error::ReqwestInvalid`] if the response was a non-OK (status
    /// code 200) response, containing the response.
    ///
    /// Returns [`Error::ReqwestUnauthorized`] if the authorization token was
    /// invalid.
    ///
    /// [`Error::Json`]: ../enum.Error.html#variant.Json
    /// [`Error::ReqwestBad`]: ../enum.Error.html#variant.ReqwestBad
    /// [`Error::ReqwestInvalid`]: ../enum.Error.html#variant.ReqwestInvalid
    /// [`Error::ReqwestUnauthorized`]: ../enum.Error.html#variant.ReqwestUnauthorized
    fn get_image_types<S>(&self, auth: S, hidden: bool) -> Result<Vec<String>>
        where S: Into<String>;

    /// Uploads an image to the Api.
    ///
    /// # Examples
    ///
    /// Upload an image after reading it from the disk:
    ///
    /// ```rust,no_run
    /// extern crate reqwest;
    /// extern crate weeb_api;
    /// # use std::error::Error;
    /// #
    /// # fn try_main() -> Result<(), Box<Error>> {
    /// #
    /// use reqwest::Client;
    /// use std::env;
    /// use std::fs::File;
    /// use std::io::Read;
    /// use weeb_api::{UploadParams, WeebApiReqwestRequester};
    ///
    /// let token = env::var("WEEB_TOKEN")?;
    ///
    /// let client = Client::new();
    ///
    /// let mut buffer = vec![];
    /// let mut file = File::open("./file.png")?;
    /// file.read_to_end(&mut buffer)?;
    /// let params = UploadParams::simple("hug".to_string(), buffer);
    ///
    /// let response = client.upload_image(token, params)?;
    ///
    /// println!("Status: {}", response.message);
    /// #     Ok(())
    /// # }
    /// #
    /// # fn main() {
    /// #     try_main().unwrap();
    /// # }
    /// ```
    ///
    /// # Errors
    ///
    /// Returns [`Error::Json`] if there was an error parsing the response
    /// body.
    ///
    /// Returns [`Error::NoUploadSpecified`] if the input did not specify one of
    /// the required image upload parameters.
    ///
    /// Returns [`Error::ReqwestBad`] if the request was otherwise bad for some
    /// reason, containing the response.
    ///
    /// Returns [`Error::ReqwestInvalid`] if the response was a non-OK (status
    /// code 200) response, containing the response.
    ///
    /// Returns [`Error::ReqwestParse`] if there was an error parsing the image
    /// parameters into a valid URL.
    ///
    /// Returns [`Error::ReqwestUnauthorized`] if the authorization token was
    /// invalid.
    ///
    /// [`Error::Json`]: ../enum.Error.html#variant.Json
    /// [`Error::NoParamsSpecified`]: ../enum.Error.html#variant.NoUploadSpecified
    /// [`Error::ReqwestBad`]: ../enum.Error.html#variant.ReqwestBad
    /// [`Error::ReqwestInvalid`]: ../enum.Error.html#variant.ReqwestInvalid
    /// [`Error::ReqwestParse`]: ../enum.Error.html#variant.ReqwestParse
    /// [`Error::ReqwestUnauthorized`]: ../enum.Error.html#variant.ReqwestUnauthorized
    fn upload_image<S>(&self, auth: S, params: UploadParams) ->
        Result<ImageUploadResponse> where S: Into<String>;
}

impl WeebApiRequester for ReqwestClient {
    fn get_images(&self) -> Result<ApiResponse> {
        handle_request(&mut self.get(constants::GET_IMAGES))
    }

    fn get_image_info<S>(&self, auth: S, id: &str) -> Result<Image>
        where S: Into<String> {
        let url = Url::parse(&format!("{}{}", constants::GET_IMAGE_INFO, id))?;

        handle_request(self.get(url).header(Authorization(auth.into())))
    }

    fn get_image_random<S>(&self, auth: S, params: ImageParams)
        -> Result<Image> where S: Into<String> {
        let built = params.into_data();

        if built.is_empty() {
            return Err(Error::NoParamsSpecified);
        }

        let url = Url::parse_with_params(constants::GET_IMAGE_RANDOM, built)?;

        handle_request(self.get(url).header(Authorization(auth.into())))
    }

    fn get_image_tags<S>(&self, auth: S, hidden: bool) -> Result<Vec<String>>
        where S: Into<String> {
        let param = [("hidden", &hidden.to_string())];
        let url = Url::parse_with_params(constants::GET_IMAGE_TAGS, &param)?;

        let mut request = self.get(url);
        request.header(Authorization(auth.into()));

        handle_request::<ImageTagsResponse>(&mut request).map(|x| x.tags)
    }

    fn get_image_types<S>(&self, auth: S, hidden: bool) -> Result<Vec<String>>
        where S: Into<String> {
        let param = [("hidden", &hidden.to_string())];
        let url = Url::parse_with_params(constants::GET_IMAGE_TYPES, &param)?;

        let mut request = self.get(url);
        request.header(Authorization(auth.into()));

        handle_request::<ImageTypesResponse>(&mut request).map(|x| x.types)
    }

    fn upload_image<S>(&self, auth: S, params: UploadParams) ->
        Result<ImageUploadResponse> where S: Into<String> {
        let (built, file) = params.into_data();

        if built.is_empty() {
            return Err(Error::NoUploadSpecified);
        }

        let url = Url::parse_with_params(constants::POST_IMAGE, built)?;

        let part = Part::reader(Cursor::new(file));
        let form = Form::new().part("file", part);

        let mut request = self.post(url);
        request.multipart(form);
        request.header(Authorization(auth.into()));

        handle_request(&mut request)
    }
}

fn handle_request<T: DeserializeOwned>(request: &mut RequestBuilder) -> Result<T> {
    let response = request.send()?;

    match response.status() {
        StatusCode::Ok => {},
        StatusCode::BadRequest => {
            return Err(Error::ReqwestBad(Box::new(response)));
        },
        StatusCode::Unauthorized => {
            return Err(Error::ReqwestUnauthorized(Box::new(response)));
        },
        _ => return Err(Error::ReqwestInvalid(Box::new(response))),
    }

    from_reader(response)
}

#[inline]
fn from_reader<T: DeserializeOwned, U: Read>(reader: U) -> Result<T> {
    serde_json::from_reader(reader).map_err(From::from)
}