Merge pull request #4 from ListenNotes/cameron-develop

Cameron develop

Author: wenbinf

examples/sample/src/main.rs

@@ -1,3 +1,4 @@
+use podcast_api::Error;
 use serde_json::json;
 
 #[tokio::main]
@@ -17,17 +18,25 @@ async fn main() {
         .await
     {
         Ok(response) => {
-            println!("Successfully called \"typeahead\" endpoint.");
+            println!("Successfully called Listen Notes API.");
             if let Ok(body) = response.json().await {
                 println!("Response Body:");
-                println!("{:?}", body);
+                println!("{}", body);
             } else {
                 println!("Response body JSON data parsing error.")
             }
         }
         Err(err) => {
-            println!("Error calling \"typeahead\" endpoint:");
-            println!("{:?},", err);
+            match err {
+                Error::NotFoundError => { println!("Not Found: {}", err); }
+                Error::AuthenticationError => { println!("Authentication Issue: {}", err); }
+                Error::RateLimitError => { println!("Rate Limit: {}", err); }
+                Error::InvalidRequestError => { println!("Invalid Request: {}", err); }
+                Error::ListenApiError => { println!("API Error: {}", err); }
+                Error::ApiConnectionError => { println!("Connection Issue: {}", err); }
+                Error::Reqwest(err) => { println!("Reqwest HTTP Client Error: {}", err); }
+                Error::Json(err) => { println!("JSON Parsing Error: {}", err); }
+            }
         }
     };
 }

rustfmt.toml

@@ -0,0 +1 @@
+max_width = 120

src/client.rs

@@ -1,4 +1,5 @@
-use super::{Api, Result};
+use super::{Api, Error, Result};
+use http::StatusCode;
 use reqwest::RequestBuilder;
 use serde_json::Value;
 use std::time::Duration;
@@ -60,11 +61,7 @@ impl Client<'_> {
     }
 
     /// Creates new Listen API Client with user provided HTTP Client.
-    pub fn new_custom<'a>(
-        client: reqwest::Client,
-        id: Option<&'a str>,
-        user_agent: Option<&'a str>,
-    ) -> Client<'a> {
+    pub fn new_custom<'a>(client: reqwest::Client, id: Option<&'a str>, user_agent: Option<&'a str>) -> Client<'a> {
         Client {
             client,
             api: if let Some(id) = id {
@@ -115,6 +112,36 @@ impl Client<'_> {
         self.post("episodes", parameters).await
     }
 
+    /// Calls [`GET /curated_podcasts/{id}`](https://www.listennotes.com/api/docs/#post-api-v2-curated_podcasts-id) with supplied parameters.
+    pub async fn fetch_curated_podcasts_list_by_id(&self, id: &str, parameters: &Value) -> Result<Response> {
+        self.get(&format!("curated_podcasts/{}", id), parameters).await
+    }
+
+    /// Calls [`GET /curated_podcasts`](https://www.listennotes.com/api/docs/#post-api-v2-curated_podcasts) with supplied parameters.
+    pub async fn fetch_curated_podcasts_lists(&self, parameters: &Value) -> Result<Response> {
+        self.get("curated_podcasts", parameters).await
+    }
+
+    /// Calls [`GET /genres`](https://www.listennotes.com/api/docs/#post-api-v2-genres) with supplied parameters.
+    pub async fn fetch_podcast_genres(&self, parameters: &Value) -> Result<Response> {
+        self.get("genres", parameters).await
+    }
+
+    /// Calls [`GET /regions`](https://www.listennotes.com/api/docs/#post-api-v2-regions) with supplied parameters.
+    pub async fn fetch_podcast_regions(&self, parameters: &Value) -> Result<Response> {
+        self.get("regions", parameters).await
+    }
+
+    /// Calls [`GET /languages`](https://www.listennotes.com/api/docs/#post-api-v2-languages) with supplied parameters.
+    pub async fn fetch_podcast_languages(&self, parameters: &Value) -> Result<Response> {
+        self.get("languages", parameters).await
+    }
+
+    /// Calls [`GET /just_listen`](https://www.listennotes.com/api/docs/#post-api-v2-just_listen) with supplied parameters.
+    pub async fn just_listen(&self, parameters: &Value) -> Result<Response> {
+        self.get("just_listen", parameters).await
+    }
+
     async fn get(&self, endpoint: &str, parameters: &Value) -> Result<Response> {
         let request = self
             .client
@@ -143,8 +170,31 @@ impl Client<'_> {
         .header("User-Agent", self.user_agent)
         .build()?;
 
+        let response = self
+            .client
+            .execute(request.try_clone().expect(
+                "Error can remain unhandled because we're not using streams, which are the try_clone fail condition",
+            ))
+            .await;
+
+        match &response {
+            Ok(response) => match response.status() {
+                StatusCode::NOT_FOUND => return Err(Error::NotFoundError),
+                StatusCode::UNAUTHORIZED => return Err(Error::AuthenticationError),
+                StatusCode::TOO_MANY_REQUESTS => return Err(Error::RateLimitError),
+                StatusCode::BAD_REQUEST => return Err(Error::InvalidRequestError),
+                StatusCode::INTERNAL_SERVER_ERROR => return Err(Error::ListenApiError),
+                _ => {}
+            },
+            Err(err) => {
+                if err.is_connect() || err.is_timeout() {
+                    return Err(Error::ApiConnectionError);
+                }
+            }
+        };
+
         Ok(Response {
-            response: self.client.execute(request.try_clone().expect("Error can remain unhandled because we're not using streams, which are the try_clone fail condition")).await?,
+            response: response?,
             request,
         })
     }

src/error.rs

@@ -1,6 +1,18 @@
 /// Error for API calls from [`Client`](super::Client).
 #[derive(Debug)]
 pub enum Error {
+    /// Wrong api key or your account is suspended.
+    AuthenticationError,
+    /// Fail to connect to API servers.
+    ApiConnectionError,
+    /// Something wrong on your end (client side errors), e.g., missing required parameters.
+    InvalidRequestError,
+    /// You are using FREE plan and you exceed the quota limit.
+    RateLimitError,
+    /// Endpoint not exist, or podcast / episode not exist.
+    NotFoundError,
+    /// Something wrong on our end (unexpected server errors).
+    ListenApiError,
     /// Error from http client.
     Reqwest(reqwest::Error),
     /// Error from JSON creation/processing.
@@ -24,12 +36,38 @@ impl std::error::Error for Error {
         match *self {
             Error::Reqwest(ref e) => Some(e),
             Error::Json(ref e) => Some(e),
+            _ => None,
         }
     }
 }
 
 impl std::fmt::Display for Error {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        write!(f, "{}", *self)
+        match self {
+            Error::AuthenticationError => {
+                write!(f, "Wrong api key or your account is suspended.")
+            }
+            Error::ApiConnectionError => {
+                write!(f, "Fail to connect to API servers.")
+            }
+            Error::InvalidRequestError => {
+                write!(
+                    f,
+                    "Something wrong on your end (client side errors), e.g., missing required parameters."
+                )
+            }
+            Error::RateLimitError => {
+                write!(f, "You are using FREE plan and you exceed the quota limit.")
+            }
+            Error::NotFoundError => {
+                write!(f, "Endpoint not exist, or podcast / episode not exist.")
+            }
+            Error::ListenApiError => {
+                write!(f, "Something wrong on our end (unexpected server errors).")
+            }
+            Error::Reqwest(_) | Error::Json(_) => {
+                write!(f, "{}", self)
+            }
+        }
     }
 }