Support for Async Actions

Author: awilczek

README.md

@@ -101,10 +101,31 @@ let was_voucher_enabled: bool = voucherify.voucher_enable("D1dsWQVE").send().unw
 let was_voucher_disabled: bool = voucherify.voucher_disable("D1dsWQVE").send().unwrap();
 ```
 
+## Async Actions API
+
+Provided methods:
+- [Get Async Actions](#get-async-action)
+- [List Async Actions](#list-async-actions)
+
+#### [Get Async Action]
+
+``` rust
+let async_action: AsyncAction = voucherify.async_action_get("id").send().unwrap();
+```
+
+#### [List Async Actions]
+
+``` rust
+let async_action_list: Vec<AsyncAction> = voucherify.async_action_list().limit(5).end_date("2021-07-16T16:10:28Z").send().unwrap();
+```
+
 ## License
 
 Licensed under MIT license ([LICENSE](LICENSE) or http://opensource.org/licenses/MIT)
 
+[Get Async Action]: https://docs.voucherify.io/reference?utm_source=github&utm_medium=sdk&utm_campaign=acq#get-async-actions-1
+[List Async Actions]: https://docs.voucherify.io/reference?utm_source=github&utm_medium=sdk&utm_campaign=acq#list-async-actions
+
 [Create Voucher]: https://docs.voucherify.io/reference?utm_source=github&utm_medium=sdk&utm_campaign=acq#create-voucher
 [Get Voucher]: https://docs.voucherify.io/reference?utm_source=github&utm_medium=sdk&utm_campaign=acq#vouchers-get
 [Update Voucher]: https://docs.voucherify.io/reference?utm_source=github&utm_medium=sdk&utm_campaign=acq#update-voucher

examples/async_actions.rs

@@ -0,0 +1,27 @@
+extern crate voucherify_rs;
+
+use voucherify_rs::Voucherify;
+use voucherify_rs::async_action::AsyncAction;
+use voucherify_rs::async_action::AsyncActionList;
+
+fn main() {
+
+    //
+    // Setup voucherify api
+    //
+    let voucherify = Voucherify::new("c70a6f00-cf91-4756-9df5-47628850002b",
+                                     "3266b9f8-e246-4f79-bdf0-833929b1380c");
+
+    //
+    // List Async Actions
+    //
+    let async_actions: AsyncActionList = voucherify.async_action_list().limit(3).end_date("2021-07-16T16:10:28Z").send().unwrap();
+    println!("Async Actions: {:?}", async_actions);
+
+    //
+    // Get Async Action
+    //
+    let async_action: AsyncAction = voucherify.async_action_get("id").send().unwrap();
+    println!("Fetched Async Action: {:?}", async_action);
+
+}

src/async_action/get.rs

@@ -0,0 +1,47 @@
+use std::io::Read;
+use hyper::Url;
+use hyper::method::Method;
+use serde_json;
+
+use request::VoucherifyRequest;
+use utils::error::VoucherifyError;
+use async_action::AsyncAction;
+
+pub struct AsyncActionGetRequest {
+    request: VoucherifyRequest,
+    app_url: String,
+
+    id: String,
+}
+
+impl AsyncActionGetRequest {
+    pub fn new(request: VoucherifyRequest, id: &str, app_url: String) -> AsyncActionGetRequest {
+        AsyncActionGetRequest {
+            request,
+            app_url,
+
+            id: id.to_string(),
+        }
+    }
+
+    pub fn send(&mut self) -> Result<AsyncAction, VoucherifyError> {
+        let url = try!(Url::parse(format!("{}/v1/async-actions/{}",
+                                          self.app_url,
+                                          self.id)
+            .as_str()));
+
+        let mut response = try!(self.request.execute(Method::Get, url));
+
+        let mut json = String::new();
+        let _ = try!(response.read_to_string(&mut json));
+
+        if !response.status.is_success() {
+            return Err(VoucherifyError::ResponseError(json))
+        }
+
+        match serde_json::from_str(json.as_str()) {
+            Ok(async_action) => Ok(async_action),
+            Err(err) => Err(VoucherifyError::JsonParse(err)),
+        }
+    }
+}

src/async_action/list.rs

@@ -0,0 +1,58 @@
+use std::io::Read;
+use hyper::Url;
+use hyper::method::Method;
+
+use request::VoucherifyRequest;
+use utils::error::VoucherifyError;
+use async_action::AsyncActionList;
+
+pub struct AsyncActionListRequest {
+    request: VoucherifyRequest,
+    app_url: String,
+
+    limit: u32,
+    end_date: String,
+}
+
+impl AsyncActionListRequest {
+    pub fn new(request: VoucherifyRequest, app_url: String) -> AsyncActionListRequest {
+        AsyncActionListRequest {
+            request,
+            app_url,
+
+            limit: 100,
+            end_date: String::new(),
+        }
+    }
+
+    pub fn limit(&mut self, limit: u32) -> &mut AsyncActionListRequest {
+        self.limit = limit;
+        self
+    }
+
+    pub fn end_date(&mut self, end_date: &str) -> &mut AsyncActionListRequest {
+        self.end_date = end_date.to_string();
+        self
+    }
+
+    pub fn send(&mut self) -> Result<AsyncActionList, VoucherifyError> {
+        let mut url = try!(Url::parse(format!("{}/v1/async-actions", self.app_url).as_str()));
+        url.query_pairs_mut()
+            .clear()
+            .append_pair("limit", format!("{}", self.limit).as_str());
+
+        if !self.end_date.is_empty() {
+            url.query_pairs_mut().append_pair("end_date", self.end_date.as_str());
+        }
+
+        let mut response = try!(self.request.execute(Method::Get, url));
+
+        let mut json = String::new();
+        let _ = try!(response.read_to_string(&mut json));
+
+        match serde_json::from_str(json.as_str()) {
+            Ok(async_action_list) => Ok(async_action_list),
+            Err(err) => Err(VoucherifyError::JsonParse(err)),
+        }
+    }
+}

src/async_action/mod.rs

@@ -0,0 +1,55 @@
+pub mod get;
+pub mod list;
+
+use std::collections::BTreeMap;
+use serde_json::Value;
+
+#[derive(Default, PartialEq, Debug, Serialize, Deserialize)]
+pub struct AsyncActionList {
+    pub async_actions: Vec<AsyncAction>
+}
+
+#[derive(Default, PartialEq, Debug, Serialize, Deserialize)]
+pub struct AsyncAction {
+    pub id: Option<String>,
+    #[serde(rename = "type")]
+    pub async_action_type: Option<String>,
+    pub status: Option<String>,
+    pub result: Option<BTreeMap<String, Value>>,
+    pub created_at: Option<String>,
+}
+
+impl AsyncAction {
+    pub fn new() -> AsyncAction {
+        AsyncAction::default()
+    }
+
+    pub fn id(mut self, id: String) -> AsyncAction {
+        self.id = Some(id);
+        self
+    }
+
+    pub fn async_action_type(mut self, async_action_type: String) -> AsyncAction {
+        self.async_action_type = Some(async_action_type);
+        self
+    }
+
+    pub fn status(mut self, status: String) -> AsyncAction {
+        self.status = Some(status);
+        self
+    }
+
+    pub fn result(mut self, result: BTreeMap<String, Value>) -> AsyncAction {
+        self.result = Some(result);
+        self
+    }
+
+    pub fn created_at(mut self, created_at: String) -> AsyncAction {
+        self.created_at = Some(created_at);
+        self
+    }
+
+    pub fn build(self) -> AsyncAction {
+        self
+    }
+}

src/lib.rs

@@ -6,9 +6,12 @@ extern crate hyper;
 extern crate hyper_native_tls;
 
 pub mod request;
+pub mod async_action;
 pub mod voucher;
 pub mod utils;
 
+use async_action::get::AsyncActionGetRequest;
+use async_action::list::AsyncActionListRequest;
 use request::VoucherifyRequest;
 use voucher::create::VoucherCreateRequest;
 use voucher::get::VoucherGetRequest;
@@ -212,4 +215,45 @@ impl Voucherify {
         let new_request = VoucherifyRequest::new(&self.app_id, &self.app_token);
         VoucherDisableRequest::new(new_request, voucher_id, self.app_url.to_string())
     }
+
+    /// Gets single Async Action by id.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use voucherify_rs::Voucherify;
+    /// use voucherify_rs::voucher::AsyncAction;
+    ///
+    /// let voucherify = Voucherify::new("c70a6f00-cf91-4756-9df5-47628850002b",
+    ///                                  "3266b9f8-e246-4f79-bdf0-833929b1380c");
+    ///
+    /// let async_action: AsyncAction = voucherify.async_action_get("id").send().unwrap();
+    ///
+    /// assert_eq!(async_action.id.unwrap(), "id");
+    /// ```
+    pub fn async_action_get(&self, id: &str) -> AsyncActionGetRequest {
+        let new_request = VoucherifyRequest::new(&self.app_id, &self.app_token);
+        AsyncActionGetRequest::new(new_request, id, self.app_url.to_string())
+    }
+
+    /// Gets a list of Async Actions.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use voucherify_rs::Voucherify;
+    /// use voucherify_rs::voucher::AsyncAction;
+    ///
+    /// let voucherify = Voucherify::new("c70a6f00-cf91-4756-9df5-47628850002b",
+    ///                                  "3266b9f8-e246-4f79-bdf0-833929b1380c");
+    ///
+    /// let async_action_list: Vec<AsyncAction> = voucherify.async_action_list().limit(5).endDate("2021-07-16T16:10:28Z").send().unwrap();
+    ///
+    /// assert!(async_action_list.len() <= 5);
+    /// ```
+    pub fn async_action_list(&self) -> AsyncActionListRequest {
+        let new_request = VoucherifyRequest::new(&self.app_id, &self.app_token);
+        AsyncActionListRequest::new(new_request, self.app_url.to_string())
+    }
+
 }