tapsilat 2026.4.3

The Tapsilat SDK for Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

use crate::error::Result;
use crate::modules::validators::Validators;
use crate::types::{
    ApiResponse, CreatePaymentRequest, PaginatedResponse, PaginationParams, Payment,
    PaymentResponse,
};
use std::sync::Arc;

pub struct PaymentModule {
    client: Arc<crate::client::TapsilatClient>,
}

impl PaymentModule {
    pub fn new(client: Arc<crate::client::TapsilatClient>) -> Self {
        Self { client }
    }

    pub fn create(&self, request: CreatePaymentRequest) -> Result<PaymentResponse> {
        // Validate request
        Validators::validate_amount(request.amount)?;

        let response = self
            .client
            .make_request("POST", "payments", Some(&request))?;
        let api_response: ApiResponse<PaymentResponse> = serde_json::from_value(response)?;

        match api_response.data {
            Some(payment_response) => Ok(payment_response),
            None => Err(crate::error::TapsilatError::InvalidResponse(
                api_response
                    .message
                    .unwrap_or("No payment data in response".to_string()),
            )),
        }
    }

    pub fn get(&self, payment_id: &str) -> Result<Payment> {
        if payment_id.is_empty() {
            return Err(crate::error::TapsilatError::ValidationError(
                "Payment ID cannot be empty".to_string(),
            ));
        }

        let endpoint = format!("payments/{}", payment_id);
        let response = self.client.make_request::<()>("GET", &endpoint, None)?;
        let api_response: ApiResponse<Payment> = serde_json::from_value(response)?;

        match api_response.data {
            Some(payment) => Ok(payment),
            None => Err(crate::error::TapsilatError::InvalidResponse(
                api_response
                    .message
                    .unwrap_or("No payment data in response".to_string()),
            )),
        }
    }

    pub fn list(&self, pagination: Option<PaginationParams>) -> Result<PaginatedResponse<Payment>> {
        let mut endpoint = "payments".to_string();

        // Add pagination parameters
        if let Some(params) = pagination {
            let mut query_params = Vec::new();

            if let Some(page) = params.page {
                query_params.push(format!("page={}", page));
            }

            if let Some(per_page) = params.per_page {
                query_params.push(format!("per_page={}", per_page));
            }

            if !query_params.is_empty() {
                endpoint.push('?');
                endpoint.push_str(&query_params.join("&"));
            }
        }

        let response = self.client.make_request::<()>("GET", &endpoint, None)?;
        let api_response: ApiResponse<PaginatedResponse<Payment>> =
            serde_json::from_value(response)?;

        match api_response.data {
            Some(paginated_payments) => Ok(paginated_payments),
            None => Err(crate::error::TapsilatError::InvalidResponse(
                api_response
                    .message
                    .unwrap_or("No payments data in response".to_string()),
            )),
        }
    }

    pub fn cancel(&self, payment_id: &str) -> Result<Payment> {
        if payment_id.is_empty() {
            return Err(crate::error::TapsilatError::ValidationError(
                "Payment ID cannot be empty".to_string(),
            ));
        }

        let endpoint = format!("payments/{}/cancel", payment_id);
        let response = self.client.make_request::<()>("POST", &endpoint, None)?;
        let api_response: ApiResponse<Payment> = serde_json::from_value(response)?;

        match api_response.data {
            Some(payment) => Ok(payment),
            None => Err(crate::error::TapsilatError::InvalidResponse(
                api_response
                    .message
                    .unwrap_or("No payment data in response".to_string()),
            )),
        }
    }
}