lago-client 0.1.24

Lago API client
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

use lago_types::{
    error::{LagoError, Result},
    requests::payment::{
        CreatePaymentRequest, GetPaymentRequest, ListCustomerPaymentsRequest, ListPaymentsRequest,
    },
    responses::payment::{CreatePaymentResponse, GetPaymentResponse, ListPaymentsResponse},
};
use url::Url;

use crate::client::LagoClient;

/// Payment-related operations for the Lago client
impl LagoClient {
    /// Retrieves a list of payments with optional filtering parameters
    ///
    /// # Arguments
    /// * `request` - Optional filtering parameters for the payment list
    ///
    /// # Returns
    /// A `Result` containing the list of payments or an error
    pub async fn list_payments(
        &self,
        request: Option<ListPaymentsRequest>,
    ) -> Result<ListPaymentsResponse> {
        let request = request.unwrap_or_default();
        let region = self.config.region()?;
        let mut url = Url::parse(&format!("{}/payments", region.endpoint()))
            .map_err(|e| LagoError::Configuration(format!("Invalid URL: {e}")))?;

        let query_params = request.to_query_params();

        if !query_params.is_empty() {
            let query_string = query_params
                .iter()
                .map(|(k, v)| format!("{k}={v}"))
                .collect::<Vec<_>>()
                .join("&");
            url.set_query(Some(&query_string));
        }

        self.make_request("GET", url.as_str(), None::<&()>).await
    }

    /// Retrieves a specific payment by its Lago ID
    ///
    /// # Arguments
    /// * `request` - The request containing the payment ID to retrieve
    ///
    /// # Returns
    /// A `Result` containing the payment data or an error
    pub async fn get_payment(&self, request: GetPaymentRequest) -> Result<GetPaymentResponse> {
        let region = self.config.region()?;
        let url = format!("{}/payments/{}", region.endpoint(), request.lago_id);
        self.make_request("GET", &url, None::<&()>).await
    }

    /// Creates a manual payment for an invoice
    ///
    /// # Arguments
    /// * `request` - The request containing the payment details
    ///
    /// # Returns
    /// A `Result` containing the created payment or an error
    pub async fn create_payment(
        &self,
        request: CreatePaymentRequest,
    ) -> Result<CreatePaymentResponse> {
        let region = self.config.region()?;
        let url = format!("{}/payments", region.endpoint());
        self.make_request("POST", &url, Some(&request)).await
    }

    /// Retrieves a list of payments for a specific customer
    ///
    /// # Arguments
    /// * `request` - The request containing the customer ID and optional filters
    ///
    /// # Returns
    /// A `Result` containing the list of payments or an error
    pub async fn list_customer_payments(
        &self,
        request: ListCustomerPaymentsRequest,
    ) -> Result<ListPaymentsResponse> {
        let region = self.config.region()?;
        let mut url = Url::parse(&format!(
            "{}/customers/{}/payments",
            region.endpoint(),
            urlencoding::encode(&request.external_customer_id)
        ))
        .map_err(|e| LagoError::Configuration(format!("Invalid URL: {e}")))?;

        let query_params = request.to_query_params();

        if !query_params.is_empty() {
            let query_string = query_params
                .iter()
                .map(|(k, v)| format!("{k}={v}"))
                .collect::<Vec<_>>()
                .join("&");
            url.set_query(Some(&query_string));
        }

        self.make_request("GET", url.as_str(), None::<&()>).await
    }
}