added partial debit transaction route

Author: morukele

README.md

@@ -4,7 +4,7 @@
 [![paystack-rs on crates.io](https://img.shields.io/crates/v/paystack-rs.svg)](https://crates.io/crates/paystack-rs)
 [![paystack-rs  on docs.rs](https://docs.rs/paystack-rs/badge.svg)](https://docs.rs/paystack-rs)
 
-Convenient rust bindings and types for the Paystakc HTTP API aiming to support the entire API surface. Not the case? Please open an issue. I update the definitions on a weekly basis.
+Convenient **Async** rust bindings and types for the Paystack HTTP API aiming to support the entire API surface. Not the case? Please open an issue. I update the definitions on a weekly basis.
 
 ## Documentation
 

examples/transaction.rs

@@ -10,7 +10,7 @@
 //! Please see the type definition to understand how it is constructed
 
 use dotenv::dotenv;
-use paystack::{Currency, PaystackClient, Status, TransactionBuilder};
+use paystack::{Channel, Currency, PaystackClient, Status, TransactionBuilder};
 use std::env;
 
 #[tokio::main]
@@ -22,8 +22,9 @@ async fn main() {
 
     let body = TransactionBuilder::new()
         .email("email@example.com")
-        .amount("2000")
+        .amount("200000")
         .currency(Currency::NGN)
+        .channels(vec![Channel::Qr, Channel::Ussd, Channel::BankTransfer])
         .build()
         .unwrap();
 

src/client.rs

@@ -6,8 +6,9 @@ extern crate reqwest;
 extern crate serde_json;
 
 use crate::{
-    Charge, PaystackResult, RequestNotSuccessful, Status, Transaction, TransactionResponse,
-    TransactionStatus, TransactionStatusList, TransactionTimeline, TransactionTotalsResponse,
+    Charge, Currency, ExportTransactionResponse, PartialDebitTransaction, PaystackResult,
+    RequestNotSuccessful, Status, Transaction, TransactionResponse, TransactionStatus,
+    TransactionStatusList, TransactionTimeline, TransactionTotalsResponse,
 };
 
 static BASE_URL: &str = "https://api.paystack.co";
@@ -90,7 +91,7 @@ impl PaystackClient {
     ///
     /// The method takes the following parameters:
     ///     - perPage (Optional): Number of transactions to return. If None is passed as the parameter, the last 10 transactions are returned.
-    ///     - status (Optional): Filter transactions by status (`failed`, `success`, `abandoned`).
+    ///     - status (Optional): Filter transactions by status, defaults to Success if no status is passed.
     ///
     pub async fn list_transactions(
         &self,
@@ -100,7 +101,7 @@ impl PaystackClient {
         let url = format!("{}/transaction", BASE_URL);
         let query = vec![
             ("perPage", number_of_transactions.unwrap_or(10).to_string()),
-            ("status", status.unwrap().to_string()),
+            ("status", status.unwrap_or(Status::Abandoned).to_string()),
         ];
 
         let response = self
@@ -238,10 +239,87 @@ impl PaystackClient {
             return Err(
                 RequestNotSuccessful::new(response.status(), response.text().await?).into(),
             );
-        }
+        };
 
         let content = response.json::<TransactionTotalsResponse>().await?;
 
         Ok(content)
     }
+
+    /// Export a list of transactions carried out on your integration
+    ///
+    /// This method takes the following parameters
+    /// - Status (Optional): The status of the transactions to export. Defaults to all
+    /// - Currency (Optional): The currency of the transactions to export. Defaults to NGN
+    /// - Settled (Optional): To state of the transactions to export. Defaults to False.
+    pub async fn export_transaction(
+        &self,
+        status: Option<Status>,
+        currency: Option<Currency>,
+        settled: Option<bool>,
+    ) -> PaystackResult<ExportTransactionResponse> {
+        let url = format!("{}/transaction/export", BASE_URL);
+
+        // Specify a default option for settled transactions.
+        let settled = match settled {
+            Some(settled) => settled.to_string(),
+            None => String::from(""),
+        };
+
+        let query = vec![
+            ("status", status.unwrap_or(Status::Success).to_string()),
+            ("currency", currency.unwrap_or(Currency::EMPTY).to_string()),
+            ("settled", settled),
+        ];
+
+        let response = self
+            .client
+            .get(url)
+            .query(&query)
+            .bearer_auth(&self.api_key)
+            .header("Content-Type", "application/json")
+            .send()
+            .await?;
+
+        if response.error_for_status_ref().is_err() {
+            return Err(
+                RequestNotSuccessful::new(response.status(), response.text().await?).into(),
+            );
+        };
+
+        let content = response.json::<ExportTransactionResponse>().await?;
+
+        Ok(content)
+    }
+
+    /// Retrieve part of a payment from a customer.
+    ///
+    /// It takes a PartialDebitTransaction type as a parameter.
+    ///
+    /// NB: it must be created with the PartialDebitTransaction Builder.
+    pub async fn partial_debit(
+        &self,
+        transaction_body: PartialDebitTransaction,
+    ) -> PaystackResult<TransactionStatus> {
+        let url = format!("{}/transaction/partial_debit", BASE_URL);
+
+        let response = self
+            .client
+            .post(url)
+            .bearer_auth(&self.api_key)
+            .header("Content-Type", "application/json")
+            .json(&transaction_body)
+            .send()
+            .await?;
+
+        if response.error_for_status_ref().is_err() {
+            return Err(
+                RequestNotSuccessful::new(response.status(), response.text().await?).into(),
+            );
+        }
+
+        let content = response.json::<TransactionStatus>().await?;
+
+        Ok(content)
+    }
 }

src/resources/paystack_enums.rs

@@ -17,6 +17,21 @@ pub enum Currency {
     USD,
     /// South African Rands
     ZAR,
+    /// Used when currency can be empty.
+    EMPTY,
+}
+
+impl fmt::Display for Currency {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let currency = match self {
+            Currency::NGN => "NGN",
+            Currency::GHS => "GHS",
+            Currency::USD => "USD",
+            Currency::ZAR => "ZAR",
+            Currency::EMPTY => "",
+        };
+        write!(f, "{}", currency)
+    }
 }
 
 #[derive(Debug, Serialize, Deserialize, Clone)]
@@ -35,13 +50,13 @@ pub enum Channel {
     MobileMoney,
     /// Payment with Bank Transfer
     BankTransfer,
+    /// Payment with Apple Pay
+    ApplePay,
 }
 
 impl fmt::Display for Channel {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "{:?}", self)
-        // or, alternatively:
-        // fmt::Debug::fmt(self, f)
     }
 }
 
@@ -52,13 +67,18 @@ pub enum Status {
     /// A successful transaction.
     Success,
     /// An abadoned transaction.
-    Abadoned,
-    /// A failed transaction
+    Abandoned,
+    /// A failed transaction.
     Failed,
 }
 
 impl fmt::Display for Status {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::Debug::fmt(self, f)
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let lowercase_string = match self {
+            Status::Success => "success",
+            Status::Abandoned => "abandoned",
+            Status::Failed => "failed",
+        };
+        write!(f, "{}", lowercase_string)
     }
 }

src/resources/transaction.rs

@@ -3,7 +3,8 @@
 //! This file contains all the structs and definitions needed to
 //! create a transaction using the paystack API.
 
-use crate::{error, Currency, PaystackResult};
+use crate::error::PaystackError;
+use crate::{Channel, Currency, PaystackResult};
 use serde::Serialize;
 
 /// This struct is used to create a transaction body for creating a transaction using the Paystack API.
@@ -27,6 +28,7 @@ pub struct TransactionBuilder {
     amount: Option<String>,
     email: Option<String>,
     currency: Option<Currency>,
+    channels: Option<Vec<Channel>>,
 }
 
 impl TransactionBuilder {
@@ -35,7 +37,7 @@ impl TransactionBuilder {
         TransactionBuilder::default()
     }
 
-    /// Specify the Transaction email
+    /// Specify email for the Transaction
     pub fn email(mut self, email: impl Into<String>) -> Self {
         self.email = Some(email.into());
         self
@@ -53,14 +55,24 @@ impl TransactionBuilder {
         self
     }
 
+    /// Specify the Tranaction channels
+    pub fn channels(mut self, channels: Vec<Channel>) -> Self {
+        self.channels = Some(channels);
+        self
+    }
+
     /// Build the Transaction object
     pub fn build(self) -> PaystackResult<Transaction> {
         let Some(email) = self.email else {
-            return Err(error::PaystackError::Transaction("email is required for transaction".to_string()))
+            return Err(
+                PaystackError::Transaction("email is required for transaction".to_string())
+            )
         };
 
         let Some(amount) = self.amount else {
-            return Err(error::PaystackError::Transaction("amount is required for transaction".to_string()))
+            return Err(
+                PaystackError::Transaction("amount is required for transaction".to_string())
+            )
         };
 
         Ok(Transaction {
@@ -70,3 +82,114 @@ impl TransactionBuilder {
         })
     }
 }
+
+/// This struct is used to create a partial debit transaction body for creating a partial debit using the Paystack API.
+///
+/// IMPORTANT: This class can only be created using the PartialDebitTransactionBuilder.
+///
+/// The struct has the following fields:
+///     - authorization_code: Authorization Code for the transaction
+///     - amount: Amount should be in the smallest unit of the currency e.g. kobo if in NGN and cents if in USD
+///     - email: Customer's email address
+///     - currency : Currency in which amount should be charged (NGN, GHS, ZAR or USD). Defaults to your integration currency.
+///     - reference (Optional): Unique transaction reference.
+///     - at_least: Minimum amount to charge
+#[derive(Debug, Clone, Serialize)]
+pub struct PartialDebitTransaction {
+    authorization_code: String,
+    amount: String,
+    email: String,
+    currency: Currency,
+    reference: Option<String>,
+    at_least: Option<String>,
+}
+
+/// Builder for the Transaction object
+#[derive(Default, Clone)]
+pub struct PartialDebitTransactionBuilder {
+    authorization_code: Option<String>,
+    amount: Option<String>,
+    email: Option<String>,
+    currency: Option<Currency>,
+    reference: Option<String>,
+    at_least: Option<String>,
+}
+
+impl PartialDebitTransactionBuilder {
+    /// Create new instance of the Partial Debit Transaction builder with default properties.
+    pub fn new() -> Self {
+        PartialDebitTransactionBuilder::default()
+    }
+
+    /// Specify the authorization code.
+    pub fn authorization_code(mut self, authorization_code: impl Into<String>) -> Self {
+        self.authorization_code = Some(authorization_code.into());
+        self
+    }
+
+    /// Specify the transaction amount.
+    pub fn amount(mut self, amount: impl Into<String>) -> Self {
+        self.amount = Some(amount.into());
+        self
+    }
+
+    /// Specify email for the Transaction.
+    pub fn email(mut self, email: impl Into<String>) -> Self {
+        self.email = Some(email.into());
+        self
+    }
+
+    /// Specify transaction currency.
+    pub fn currency(mut self, currency: Currency) -> Self {
+        self.currency = Some(currency);
+        self
+    }
+
+    /// Specify the transaction reference.
+    pub fn reference(mut self, reference: impl Into<String>) -> Self {
+        self.reference = Some(reference.into());
+        self
+    }
+
+    /// Specify the minimum amount to charge for the transaction.
+    pub fn at_least(mut self, at_least: impl Into<String>) -> Self {
+        self.at_least = Some(at_least.into());
+        self
+    }
+
+    /// Build the PartialDebitTransaction object
+    pub fn build(self) -> PaystackResult<PartialDebitTransaction> {
+        let Some(authorization_code) = self.authorization_code else {
+            return Err(
+                PaystackError::Transaction("authorization code is required for partial debit transaction".to_string())
+            )
+        };
+
+        let Some(email) = self.email else {
+            return Err(
+                PaystackError::Transaction("email is required for transaction".to_string())
+            )
+        };
+
+        let Some(currency) = self.currency else {
+            return Err(
+                PaystackError::Transaction("currency is required for transaction".to_string())
+            )
+        };
+
+        let Some(amount) = self.amount else {
+            return Err(
+                PaystackError::Transaction("amount is required for transaction".to_string())
+            )
+        };
+
+        Ok(PartialDebitTransaction {
+            authorization_code,
+            email,
+            amount,
+            currency,
+            reference: self.reference,
+            at_least: self.at_least,
+        })
+    }
+}