Skip to main content

rust_nicepay/services/snap/
request_direct_debit.rs

1use crate::models::snap::check_status_direct_debit_model::CheckStatusDirectDebitModel;
2use crate::models::snap::refund_direct_debit_model::RefundDirectDebitModel;
3use crate::models::snap::regist_direct_debit_model::RegistDirectDebitModel;
4use crate::utils::config::Config;
5use crate::utils::helper::Helper;
6use reqwest::{Client, Error, Response};
7use std::future::Future;
8use std::pin::Pin;
9
10pub type MyFuture<T> = Pin<Box<dyn Future<Output = Result<T, Error>> + Send>>;
11
12pub struct DirectDebitSNAPRequester<'a> {
13    pub config: &'a Config,
14}
15
16impl<'a> DirectDebitSNAPRequester<'a> {
17    pub fn new(config: &'a Config) -> Self {
18        Self { config }
19    }
20
21    pub fn request_regist_direct_debit(
22        &self,
23        req_debit: RegistDirectDebitModel,
24        access_token: &str,
25        x_external_id: &str,
26    ) -> MyFuture<Response> {
27        let base_url = self.config.get_snap_api_base_url();
28        let url = format!("{}/api/v1.0/debit/payment-host-to-host", base_url);
29        let encoded_payload =
30            Helper::hex_encoded_payload(&req_debit).expect("Failed to hex encode");
31
32        let x_timestamp = Helper::get_formatted_date();
33        let string_to_sign = format!(
34            "POST:/api/v1.0/debit/payment-host-to-host:{}:{}:{}",
35            access_token, encoded_payload, x_timestamp
36        );
37        let x_signature = Helper::hash_with_hmac256(&self.config.client_secret, &string_to_sign)
38            .expect("Failed to sign");
39
40        let mut headers = reqwest::header::HeaderMap::new();
41        headers.insert(
42            reqwest::header::CONTENT_TYPE,
43            "application/json".parse().unwrap(),
44        );
45        headers.insert(
46            "Authorization",
47            format!("Bearer {}", access_token).parse().unwrap(),
48        );
49        headers.insert("X-TIMESTAMP", x_timestamp.parse().unwrap());
50        headers.insert("X-PARTNER-ID", self.config.client_id.parse().unwrap());
51        headers.insert("X-SIGNATURE", x_signature.parse().unwrap());
52        headers.insert("X-EXTERNAL-ID", x_external_id.parse().unwrap());
53        headers.insert("CHANNEL-ID", self.config.channel_id.parse().unwrap());
54
55        let client = Client::new();
56
57        let fut = async move {
58            let response = client
59                .post(url)
60                .headers(headers)
61                .json(&req_debit)
62                .send()
63                .await?;
64            Ok(response)
65        };
66
67        Box::pin(fut)
68    }
69
70    pub fn request_check_status_direct_debit(
71        &self,
72        req_debit: CheckStatusDirectDebitModel,
73        access_token: &str,
74        x_external_id: &str,
75    ) -> MyFuture<Response> {
76        let base_url = self.config.get_snap_api_base_url();
77        let url = format!("{}/api/v1.0/debit/status", base_url);
78        let encoded_payload =
79            Helper::hex_encoded_payload(&req_debit).expect("Failed to hex encode");
80
81        let x_timestamp = Helper::get_formatted_date();
82        let string_to_sign = format!(
83            "POST:/api/v1.0/debit/status:{}:{}:{}",
84            access_token, encoded_payload, x_timestamp
85        );
86        let x_signature = Helper::hash_with_hmac256(&self.config.client_secret, &string_to_sign)
87            .expect("Failed to sign");
88
89        let mut headers = reqwest::header::HeaderMap::new();
90        headers.insert(
91            reqwest::header::CONTENT_TYPE,
92            "application/json".parse().unwrap(),
93        );
94        headers.insert(
95            "Authorization",
96            format!("Bearer {}", access_token).parse().unwrap(),
97        );
98        headers.insert("X-TIMESTAMP", x_timestamp.parse().unwrap());
99        headers.insert("X-PARTNER-ID", self.config.client_id.parse().unwrap());
100        headers.insert("X-SIGNATURE", x_signature.parse().unwrap());
101        headers.insert("X-EXTERNAL-ID", x_external_id.parse().unwrap());
102        headers.insert("CHANNEL-ID", self.config.channel_id.parse().unwrap());
103
104        let client = Client::new();
105
106        let fut = async move {
107            let response = client
108                .post(url)
109                .headers(headers)
110                .json(&req_debit)
111                .send()
112                .await?;
113            Ok(response)
114        };
115
116        Box::pin(fut)
117    }
118
119    pub fn request_refund_direct_debit(
120        &self,
121        req_debit: RefundDirectDebitModel,
122        access_token: &str,
123        x_external_id: &str,
124    ) -> MyFuture<Response> {
125        let base_url = self.config.get_snap_api_base_url();
126        let url = format!("{}/api/v1.0/debit/refund", base_url);
127        let encoded_payload =
128            Helper::hex_encoded_payload(&req_debit).expect("Failed to hex encode");
129
130        let x_timestamp = Helper::get_formatted_date();
131        let string_to_sign = format!(
132            "POST:/api/v1.0/debit/refund:{}:{}:{}",
133            access_token, encoded_payload, x_timestamp
134        );
135        let x_signature = Helper::hash_with_hmac256(&self.config.client_secret, &string_to_sign)
136            .expect("Failed to sign");
137
138        let mut headers = reqwest::header::HeaderMap::new();
139        headers.insert(
140            reqwest::header::CONTENT_TYPE,
141            "application/json".parse().unwrap(),
142        );
143        headers.insert(
144            "Authorization",
145            format!("Bearer {}", access_token).parse().unwrap(),
146        );
147        headers.insert("X-TIMESTAMP", x_timestamp.parse().unwrap());
148        headers.insert("X-PARTNER-ID", self.config.client_id.parse().unwrap());
149        headers.insert("X-SIGNATURE", x_signature.parse().unwrap());
150        headers.insert("X-EXTERNAL-ID", x_external_id.parse().unwrap());
151        headers.insert("CHANNEL-ID", self.config.channel_id.parse().unwrap());
152
153        let client = Client::new();
154
155        let fut = async move {
156            let response = client
157                .post(url)
158                .headers(headers)
159                .json(&req_debit)
160                .send()
161                .await?;
162            Ok(response)
163        };
164
165        Box::pin(fut)
166    }
167}