iyzipay_rust/model/
checkout.rs

1use log::debug;
2
3use crate::client::HttpClient;
4use crate::model::payment::PaymentResource;
5use crate::options::Options;
6use crate::requests::CreateCheckoutFormInitializeRequest;
7use crate::requests::PKISerialize;
8use crate::requests::RetrieveCheckoutFormRequest;
9use crate::resource::IyzipayResource;
10use crate::types::Result;
11
12#[derive(Debug, Default, Serialize, Deserialize)]
13#[serde(rename_all = "camelCase")]
14#[serde(default)]
15pub struct CheckoutFormInitialize {
16    #[serde(flatten)]
17    resource: CheckoutFormInitializeResource,
18}
19
20impl CheckoutFormInitialize {
21    pub fn create(
22        req: &CreateCheckoutFormInitializeRequest,
23        options: &Options,
24    ) -> Result<CheckoutFormInitialize> {
25        let request = serde_json::to_string(req)?;
26        debug!("RequestBody:{}", request);
27        let res = HttpClient::create().post(
28            format!(
29                "{}{}",
30                options.base_url(),
31                "/payment/iyzipos/checkoutform/initialize/auth/ecom"
32            )
33            .as_str(),
34            request,
35            IyzipayResource::get_http_headers(req.serialize().unwrap_or_default(), &options),
36        )?;
37        let response = res.json()?;
38        Ok(response)
39    }
40}
41
42impl std::ops::Deref for CheckoutFormInitialize {
43    type Target = CheckoutFormInitializeResource;
44    fn deref(&self) -> &Self::Target {
45        &self.resource
46    }
47}
48
49#[derive(Debug, Default, Serialize, Deserialize)]
50#[serde(rename_all = "camelCase")]
51#[serde(default)]
52pub struct CheckoutFormInitializeResource {
53    #[serde(flatten)]
54    resource: IyzipayResource,
55
56    token: Option<String>,
57
58    checkout_form_content: Option<String>,
59
60    token_expire_time: Option<i64>,
61
62    payment_page_url: Option<String>,
63}
64
65impl CheckoutFormInitializeResource {
66    pub fn set_token<T: Into<String>>(&mut self, token: T) {
67        self.token = Some(token.into());
68    }
69
70    pub fn set_checkout_form_content<T: Into<String>>(&mut self, checkout_form_content: T) {
71        self.checkout_form_content = Some(checkout_form_content.into());
72    }
73
74    pub fn set_token_expire_time<T: Into<i64>>(&mut self, token_expire_time: T) {
75        self.token_expire_time = Some(token_expire_time.into());
76    }
77
78    pub fn set_payment_page_url<T: Into<String>>(&mut self, payment_page_url: T) {
79        self.payment_page_url = Some(payment_page_url.into());
80    }
81
82    pub fn token(&self) -> Option<&String> {
83        self.token.as_ref()
84    }
85    pub fn checkout_form_content(&self) -> Option<&String> {
86        self.checkout_form_content.as_ref()
87    }
88    pub fn token_expire_time(&self) -> Option<&i64> {
89        self.token_expire_time.as_ref()
90    }
91    pub fn payment_page_url(&self) -> Option<&String> {
92        self.payment_page_url.as_ref()
93    }
94}
95
96impl std::ops::Deref for CheckoutFormInitializeResource {
97    type Target = IyzipayResource;
98    fn deref(&self) -> &Self::Target {
99        &self.resource
100    }
101}
102
103#[derive(Debug, Default, Serialize, Deserialize)]
104#[serde(rename_all = "camelCase")]
105#[serde(default)]
106pub struct CheckoutForm {
107    #[serde(flatten)]
108    resource: PaymentResource,
109
110    token: Option<String>,
111
112    callback_url: Option<String>,
113}
114
115impl CheckoutForm {
116    pub fn retrieve(req: &RetrieveCheckoutFormRequest, options: &Options) -> Result<CheckoutForm> {
117        let request = serde_json::to_string(req)?;
118        debug!("RequestBody:{}", request);
119        let res = HttpClient::create().post(
120            format!(
121                "{}{}",
122                options.base_url(),
123                "/payment/iyzipos/checkoutform/auth/ecom/detail"
124            )
125            .as_str(),
126            request,
127            IyzipayResource::get_http_headers(req.serialize().unwrap_or_default(), &options),
128        )?;
129        let response = res.json()?;
130        Ok(response)
131    }
132
133    pub fn set_token<T: Into<String>>(&mut self, token: T) {
134        self.token = Some(token.into());
135    }
136
137    pub fn set_callback_url<T: Into<String>>(&mut self, callback_url: T) {
138        self.callback_url = Some(callback_url.into());
139    }
140
141    pub fn token(&self) -> Option<&String> {
142        self.token.as_ref()
143    }
144    pub fn callback_url(&self) -> Option<&String> {
145        self.callback_url.as_ref()
146    }
147}
148
149impl std::ops::Deref for CheckoutForm {
150    type Target = PaymentResource;
151    fn deref(&self) -> &Self::Target {
152        &self.resource
153    }
154}