1use bigdecimal::BigDecimal;
2
3use crate::model::Address;
4use crate::model::BasketItem;
5use crate::model::Buyer;
6use crate::model::PaymentCard;
7use crate::model::RefundReason;
8use crate::requests::PKISerialize;
9use crate::requests::Request;
10use crate::requests::RequestStringBuilder;
11
12#[derive(Debug, Default, Serialize, Deserialize)]
13#[serde(rename_all = "camelCase")]
14pub struct CreatePaymentRequest {
15 #[serde(flatten)]
16 request: Request,
17
18 price: Option<BigDecimal>,
19
20 paid_price: Option<BigDecimal>,
21
22 installment: Option<u8>,
23
24 payment_channel: Option<String>,
25
26 basket_id: Option<String>,
27
28 payment_group: Option<String>,
29
30 payment_card: Option<PaymentCard>,
31
32 buyer: Option<Buyer>,
33
34 shipping_address: Option<Address>,
35
36 billing_address: Option<Address>,
37
38 basket_items: Option<Vec<BasketItem>>,
39
40 payment_source: Option<String>,
41
42 currency: Option<String>,
43
44 pos_order_id: Option<String>,
45
46 connector_name: Option<String>,
47
48 callback_url: Option<String>,
49}
50
51impl CreatePaymentRequest {
52 pub fn new() -> Self {
53 CreatePaymentRequest::default()
54 }
55
56 pub fn set_price<T: Into<BigDecimal>>(&mut self, price: T) {
57 self.price = Some(price.into());
58 }
59
60 pub fn set_paid_price<T: Into<BigDecimal>>(&mut self, paid_price: T) {
61 self.paid_price = Some(paid_price.into());
62 }
63
64 pub fn set_installment<T: Into<u8>>(&mut self, installment: T) {
65 self.installment = Some(installment.into());
66 }
67
68 pub fn set_payment_channel<T: Into<String>>(&mut self, payment_channel: T) {
69 self.payment_channel = Some(payment_channel.into());
70 }
71
72 pub fn set_basket_id<T: Into<String>>(&mut self, basket_id: T) {
73 self.basket_id = Some(basket_id.into());
74 }
75
76 pub fn set_payment_group<T: Into<String>>(&mut self, payment_group: T) {
77 self.payment_group = Some(payment_group.into());
78 }
79
80 pub fn set_payment_card<T: Into<PaymentCard>>(&mut self, payment_card: T) {
81 self.payment_card = Some(payment_card.into());
82 }
83
84 pub fn set_buyer<T: Into<Buyer>>(&mut self, buyer: T) {
85 self.buyer = Some(buyer.into());
86 }
87
88 pub fn set_shipping_address<T: Into<Address>>(&mut self, shipping_address: T) {
89 self.shipping_address = Some(shipping_address.into());
90 }
91
92 pub fn set_billing_address<T: Into<Address>>(&mut self, billing_address: T) {
93 self.billing_address = Some(billing_address.into());
94 }
95
96 pub fn set_basket_items<T: Into<Vec<BasketItem>>>(&mut self, basket_items: T) {
97 self.basket_items = Some(basket_items.into());
98 }
99
100 pub fn set_payment_source<T: Into<String>>(&mut self, payment_source: T) {
101 self.payment_source = Some(payment_source.into());
102 }
103
104 pub fn set_currency<T: Into<String>>(&mut self, currency: T) {
105 self.currency = Some(currency.into());
106 }
107
108 pub fn set_pos_order_id<T: Into<String>>(&mut self, pos_order_id: T) {
109 self.pos_order_id = Some(pos_order_id.into());
110 }
111
112 pub fn set_connector_name<T: Into<String>>(&mut self, connector_name: T) {
113 self.connector_name = Some(connector_name.into());
114 }
115
116 pub fn set_callback_url<T: Into<String>>(&mut self, callback_url: T) {
117 self.callback_url = Some(callback_url.into());
118 }
119
120 pub fn price(&self) -> Option<&BigDecimal> {
121 self.price.as_ref()
122 }
123 pub fn paid_price(&self) -> Option<&BigDecimal> {
124 self.paid_price.as_ref()
125 }
126 pub fn installment(&self) -> Option<&u8> {
127 self.installment.as_ref()
128 }
129 pub fn payment_channel(&self) -> Option<&String> {
130 self.payment_channel.as_ref()
131 }
132 pub fn basket_id(&self) -> Option<&String> {
133 self.basket_id.as_ref()
134 }
135 pub fn payment_group(&self) -> Option<&String> {
136 self.payment_group.as_ref()
137 }
138 pub fn payment_card(&self) -> Option<&PaymentCard> {
139 self.payment_card.as_ref()
140 }
141 pub fn buyer(&self) -> Option<&Buyer> {
142 self.buyer.as_ref()
143 }
144 pub fn shipping_address(&self) -> Option<&Address> {
145 self.shipping_address.as_ref()
146 }
147 pub fn billing_address(&self) -> Option<&Address> {
148 self.billing_address.as_ref()
149 }
150 pub fn basket_items(&self) -> Option<&Vec<BasketItem>> {
151 self.basket_items.as_ref()
152 }
153 pub fn payment_source(&self) -> Option<&String> {
154 self.payment_source.as_ref()
155 }
156 pub fn currency(&self) -> Option<&String> {
157 self.currency.as_ref()
158 }
159 pub fn pos_order_id(&self) -> Option<&String> {
160 self.pos_order_id.as_ref()
161 }
162 pub fn connector_name(&self) -> Option<&String> {
163 self.connector_name.as_ref()
164 }
165 pub fn callback_url(&self) -> Option<&String> {
166 self.callback_url.as_ref()
167 }
168}
169
170impl std::ops::Deref for CreatePaymentRequest {
171 type Target = Request;
172 fn deref(&self) -> &Self::Target {
173 &self.request
174 }
175}
176
177impl std::ops::DerefMut for CreatePaymentRequest {
178 fn deref_mut(&mut self) -> &mut Self::Target {
179 &mut self.request
180 }
181}
182
183impl PKISerialize for CreatePaymentRequest {
184 fn serialize(&self) -> Option<String> {
185 let mut ser = RequestStringBuilder::new();
186 ser.append_option_val(self.request.serialize());
187 ser.append_price_option("price", self.price.as_ref());
188 ser.append_price_option("paidPrice", self.paid_price.as_ref());
189 ser.append_option("installment", self.installment);
190 ser.append_option("paymentChannel", self.payment_channel.as_ref());
191 ser.append_option("basketId", self.basket_id.as_ref());
192 ser.append_option("paymentGroup", self.payment_group.as_ref());
193 ser.append_option("paymentCard", self.payment_card.serialize());
194 ser.append_option("buyer", self.buyer.serialize());
195 ser.append_option("shippingAddress", self.shipping_address.serialize());
196 ser.append_option("billingAddress", self.billing_address.serialize());
197 ser.append_option("basketItems", self.basket_items.serialize());
198 ser.append_option("paymentSource", self.payment_source.as_ref());
199 ser.append_option("posOrderId", self.pos_order_id.as_ref());
200 ser.append_option("currency", self.currency.as_ref());
201 ser.append_option("connectorName", self.connector_name.as_ref());
202 ser.append_option("callbackUrl", self.callback_url.as_ref());
203 Option::from(ser.build(true))
204 }
205}
206
207#[derive(Debug, Default, Serialize, Deserialize)]
208#[serde(rename_all = "camelCase")]
209pub struct RetrievePaymentRequest {
210 #[serde(flatten)]
211 request: Request,
212
213 payment_id: Option<String>,
214
215 payment_conversation_id: Option<String>,
216}
217
218impl RetrievePaymentRequest {
219 pub fn new() -> Self {
220 RetrievePaymentRequest::default()
221 }
222
223 pub fn set_payment_id<S: Into<String>>(&mut self, payment_id: S) {
224 self.payment_id = Some(payment_id.into());
225 }
226
227 pub fn set_payment_conversation_id<S: Into<String>>(&mut self, payment_conversation_id: S) {
228 self.payment_conversation_id = Some(payment_conversation_id.into());
229 }
230}
231
232impl PKISerialize for RetrievePaymentRequest {
233 fn serialize(&self) -> Option<String> {
234 let mut ser = RequestStringBuilder::new();
235 ser.append_option_val(self.request.serialize());
236 ser.append_option("paymentId", self.payment_id.as_ref());
237 ser.append_option(
238 "paymentConversationId",
239 self.payment_conversation_id.as_ref(),
240 );
241 Option::from(ser.build(true))
242 }
243}
244
245impl std::ops::Deref for RetrievePaymentRequest {
246 type Target = Request;
247 fn deref(&self) -> &Self::Target {
248 &self.request
249 }
250}
251
252impl std::ops::DerefMut for RetrievePaymentRequest {
253 fn deref_mut(&mut self) -> &mut Self::Target {
254 &mut self.request
255 }
256}
257
258#[derive(Debug, Default, Serialize, Deserialize)]
259#[serde(rename_all = "camelCase")]
260pub struct CreateCancelRequest {
261 #[serde(flatten)]
262 request: Request,
263
264 payment_id: Option<String>,
265
266 ip: Option<String>,
267
268 reason: Option<RefundReason>,
269
270 description: Option<String>,
271}
272
273impl CreateCancelRequest {
274 pub fn new() -> Self {
275 CreateCancelRequest::default()
276 }
277
278 pub fn set_payment_id<S: Into<String>>(&mut self, payment_id: S) {
279 self.payment_id = Some(payment_id.into());
280 }
281
282 pub fn set_ip<S: Into<String>>(&mut self, ip: S) {
283 self.ip = Some(ip.into());
284 }
285
286 pub fn set_reason(&mut self, reason: RefundReason) {
287 self.reason = Some(reason);
288 }
289
290 pub fn set_description<S: Into<String>>(&mut self, description: S) {
291 self.description = Some(description.into());
292 }
293}
294
295impl PKISerialize for CreateCancelRequest {
296 fn serialize(&self) -> Option<String> {
297 let mut ser = RequestStringBuilder::new();
298 ser.append_option_val(self.request.serialize());
299 ser.append_option("paymentId", self.payment_id.as_ref());
300 ser.append_option("ip", self.ip.as_ref());
301 ser.append_option("reason", self.reason.serialize());
302 ser.append_option("description", self.description.as_ref());
303 Option::from(ser.build(true))
304 }
305}
306
307impl std::ops::Deref for CreateCancelRequest {
308 type Target = Request;
309 fn deref(&self) -> &Self::Target {
310 &self.request
311 }
312}
313
314impl std::ops::DerefMut for CreateCancelRequest {
315 fn deref_mut(&mut self) -> &mut Self::Target {
316 &mut self.request
317 }
318}
319
320#[derive(Debug, Default, Serialize, Deserialize)]
321#[serde(rename_all = "camelCase")]
322pub struct CreateThreedsPaymentRequest {
323 #[serde(flatten)]
324 request: Request,
325
326 payment_id: Option<String>,
327
328 conversation_data: Option<String>,
329}
330
331impl CreateThreedsPaymentRequest {
332 pub fn new() -> Self {
333 CreateThreedsPaymentRequest::default()
334 }
335
336 pub fn set_payment_id<T: Into<String>>(&mut self, payment_id: T) {
337 self.payment_id = Some(payment_id.into());
338 }
339
340 pub fn set_conversation_data<T: Into<String>>(&mut self, conversation_data: T) {
341 self.conversation_data = Some(conversation_data.into());
342 }
343
344 pub fn payment_id(&self) -> Option<&String> {
345 self.payment_id.as_ref()
346 }
347 pub fn conversation_data(&self) -> Option<&String> {
348 self.conversation_data.as_ref()
349 }
350}
351
352impl PKISerialize for CreateThreedsPaymentRequest {
353 fn serialize(&self) -> Option<String> {
354 let mut ser = RequestStringBuilder::new();
355 ser.append_option_val(self.request.serialize());
356 ser.append_option("paymentId", self.payment_id.as_ref());
357 ser.append_option("conversationData", self.conversation_data.as_ref());
358 Option::from(ser.build(true))
359 }
360}
361
362impl std::ops::Deref for CreateThreedsPaymentRequest {
363 type Target = Request;
364 fn deref(&self) -> &Self::Target {
365 &self.request
366 }
367}
368
369impl std::ops::DerefMut for CreateThreedsPaymentRequest {
370 fn deref_mut(&mut self) -> &mut Self::Target {
371 &mut self.request
372 }
373}
374
375#[derive(Debug, Default, Serialize, Deserialize)]
376#[serde(rename_all = "camelCase")]
377pub struct CreateRefundRequest {
378 #[serde(flatten)]
379 request: Request,
380
381 payment_transaction_id: Option<String>,
382
383 price: Option<BigDecimal>,
384
385 ip: Option<String>,
386
387 currency: Option<String>,
388
389 reason: Option<RefundReason>,
390
391 description: Option<String>,
392}
393
394impl CreateRefundRequest {
395 pub fn new() -> Self {
396 CreateRefundRequest::default()
397 }
398
399 pub fn set_payment_transaction_id<T: Into<String>>(&mut self, payment_transaction_id: T) {
400 self.payment_transaction_id = Some(payment_transaction_id.into());
401 }
402
403 pub fn set_price<T: Into<BigDecimal>>(&mut self, price: T) {
404 self.price = Some(price.into());
405 }
406
407 pub fn set_ip<T: Into<String>>(&mut self, ip: T) {
408 self.ip = Some(ip.into());
409 }
410
411 pub fn set_currency<T: Into<String>>(&mut self, currency: T) {
412 self.currency = Some(currency.into());
413 }
414
415 pub fn set_reason<T: Into<RefundReason>>(&mut self, reason: T) {
416 self.reason = Some(reason.into());
417 }
418
419 pub fn set_description<T: Into<String>>(&mut self, description: T) {
420 self.description = Some(description.into());
421 }
422
423 pub fn payment_transaction_id(&self) -> Option<&String> {
424 self.payment_transaction_id.as_ref()
425 }
426 pub fn price(&self) -> Option<&BigDecimal> {
427 self.price.as_ref()
428 }
429 pub fn ip(&self) -> Option<&String> {
430 self.ip.as_ref()
431 }
432 pub fn currency(&self) -> Option<&String> {
433 self.currency.as_ref()
434 }
435 pub fn reason(&self) -> Option<&RefundReason> {
436 self.reason.as_ref()
437 }
438 pub fn description(&self) -> Option<&String> {
439 self.description.as_ref()
440 }
441}
442
443impl PKISerialize for CreateRefundRequest {
444 fn serialize(&self) -> Option<String> {
445 let mut ser = RequestStringBuilder::new();
446 ser.append_option_val(self.request.serialize());
447 ser.append_option("paymentTransactionId", self.payment_transaction_id.as_ref());
448 ser.append_price_option("price", self.price.as_ref());
449 ser.append_option("ip", self.ip.as_ref());
450 ser.append_option("currency", self.currency.as_ref());
451 ser.append_option("reason", self.reason.serialize());
452 ser.append_option("description", self.description.as_ref());
453 Some(ser.build(true))
454 }
455}
456
457impl std::ops::Deref for CreateRefundRequest {
458 type Target = Request;
459 fn deref(&self) -> &Self::Target {
460 &self.request
461 }
462}
463
464impl std::ops::DerefMut for CreateRefundRequest {
465 fn deref_mut(&mut self) -> &mut Self::Target {
466 &mut self.request
467 }
468}
469
470#[derive(Debug, Default, Serialize, Deserialize)]
471#[serde(rename_all = "camelCase")]
472pub struct CreateBkmInitializeRequest {
473 #[serde(flatten)]
474 request: Request,
475
476 price: Option<BigDecimal>,
477
478 basket_id: Option<String>,
479
480 payment_group: Option<String>,
481
482 buyer: Option<Buyer>,
483
484 shipping_address: Option<Address>,
485
486 billing_address: Option<Address>,
487
488 basket_items: Option<Vec<BasketItem>>,
489
490 callback_url: Option<String>,
491
492 payment_source: Option<String>,
493
494 currency: Option<String>,
495
496 enabled_installments: Option<Vec<u8>>,
497}
498
499impl CreateBkmInitializeRequest {
500 pub fn new() -> Self {
501 CreateBkmInitializeRequest::default()
502 }
503
504 pub fn set_price<S: Into<BigDecimal>>(&mut self, price: S) {
505 self.price = Some(price.into());
506 }
507
508 pub fn set_basket_id<S: Into<String>>(&mut self, basket_id: S) {
509 self.basket_id = Some(basket_id.into());
510 }
511
512 pub fn set_payment_group<S: Into<String>>(&mut self, payment_group: S) {
513 self.payment_group = Some(payment_group.into());
514 }
515
516 pub fn set_buyer<S: Into<Buyer>>(&mut self, buyer: S) {
517 self.buyer = Some(buyer.into());
518 }
519
520 pub fn set_shipping_address<S: Into<Address>>(&mut self, shipping_address: S) {
521 self.shipping_address = Some(shipping_address.into());
522 }
523
524 pub fn set_billing_address<S: Into<Address>>(&mut self, billing_address: S) {
525 self.billing_address = Some(billing_address.into());
526 }
527
528 pub fn set_basket_items<S: Into<Vec<BasketItem>>>(&mut self, basket_items: S) {
529 self.basket_items = Some(basket_items.into());
530 }
531
532 pub fn set_callback_url<S: Into<String>>(&mut self, callback_url: S) {
533 self.callback_url = Some(callback_url.into());
534 }
535
536 pub fn set_payment_source<S: Into<String>>(&mut self, payment_source: S) {
537 self.payment_source = Some(payment_source.into());
538 }
539
540 pub fn set_currency<S: Into<String>>(&mut self, currency: S) {
541 self.currency = Some(currency.into());
542 }
543
544 pub fn set_enabled_installments<S: Into<Vec<u8>>>(&mut self, enabled_installments: S) {
545 self.enabled_installments = Some(enabled_installments.into());
546 }
547}
548
549impl PKISerialize for CreateBkmInitializeRequest {
550 fn serialize(&self) -> Option<String> {
551 let mut ser = RequestStringBuilder::new();
552 ser.append_option_val(self.request.serialize());
553 ser.append_price_option("price", self.price.as_ref());
554 ser.append_option("basketId", self.basket_id.as_ref());
555 ser.append_option("paymentGroup", self.payment_group.as_ref());
556 ser.append_option("buyer", self.buyer.serialize());
557 ser.append_option("shippingAddress", self.shipping_address.serialize());
558 ser.append_option("billingAddress", self.billing_address.serialize());
559 ser.append_option("basketItems", self.basket_items.serialize());
560 ser.append_option("callbackUrl", self.callback_url.as_ref());
561 ser.append_option("paymentSource", self.payment_source.as_ref());
562 ser.append_option("enabledInstallments", self.enabled_installments.serialize());
563 Some(ser.build(true))
564 }
565}
566
567impl std::ops::Deref for CreateBkmInitializeRequest {
568 type Target = Request;
569 fn deref(&self) -> &Self::Target {
570 &self.request
571 }
572}
573
574impl std::ops::DerefMut for CreateBkmInitializeRequest {
575 fn deref_mut(&mut self) -> &mut Self::Target {
576 &mut self.request
577 }
578}
579
580#[derive(Debug, Default, Serialize, Deserialize)]
581#[serde(rename_all = "camelCase")]
582pub struct RetrieveBkmRequest {
583 #[serde(flatten)]
584 request: Request,
585
586 token: Option<String>,
587}
588
589impl RetrieveBkmRequest {
590 pub fn new() -> Self {
591 RetrieveBkmRequest::default()
592 }
593
594 pub fn set_token<S: Into<String>>(&mut self, token: S) {
595 self.token = Some(token.into());
596 }
597}
598
599impl PKISerialize for RetrieveBkmRequest {
600 fn serialize(&self) -> Option<String> {
601 let mut ser = RequestStringBuilder::new();
602 ser.append_option_val(self.request.serialize());
603 ser.append_option("token", self.token.as_ref());
604 Some(ser.build(true))
605 }
606}
607
608impl std::ops::Deref for RetrieveBkmRequest {
609 type Target = Request;
610 fn deref(&self) -> &Self::Target {
611 &self.request
612 }
613}
614
615impl std::ops::DerefMut for RetrieveBkmRequest {
616 fn deref_mut(&mut self) -> &mut Self::Target {
617 &mut self.request
618 }
619}
620
621#[derive(Debug, Default, Serialize, Deserialize)]
622#[serde(rename_all = "camelCase")]
623pub struct RetrieveTransactionsRequest {
624 #[serde(flatten)]
625 request: Request,
626
627 date: Option<String>,
628}
629
630impl RetrieveTransactionsRequest {
631 pub fn new() -> Self {
632 RetrieveTransactionsRequest::default()
633 }
634
635 pub fn set_date<S: Into<String>>(&mut self, date: S) {
636 self.date = Some(date.into());
637 }
638}
639
640impl PKISerialize for RetrieveTransactionsRequest {
641 fn serialize(&self) -> Option<String> {
642 let mut ser = RequestStringBuilder::new();
643 ser.append_option_val(self.request.serialize());
644 ser.append_option("date", self.date.as_ref());
645 Some(ser.build(true))
646 }
647}
648
649impl std::ops::Deref for RetrieveTransactionsRequest {
650 type Target = Request;
651 fn deref(&self) -> &Self::Target {
652 &self.request
653 }
654}
655
656impl std::ops::DerefMut for RetrieveTransactionsRequest {
657 fn deref_mut(&mut self) -> &mut Self::Target {
658 &mut self.request
659 }
660}
661
662#[derive(Debug, Default, Serialize, Deserialize)]
663#[serde(rename_all = "camelCase")]
664pub struct CreatePeccoInitializeRequest {
665 #[serde(flatten)]
666 request: Request,
667
668 price: Option<BigDecimal>,
669
670 paid_price: Option<BigDecimal>,
671
672 basket_id: Option<String>,
673
674 payment_group: Option<String>,
675
676 payment_source: Option<String>,
677
678 currency: Option<String>,
679
680 buyer: Option<Buyer>,
681
682 shipping_address: Option<Address>,
683
684 billing_address: Option<Address>,
685
686 basket_items: Option<Vec<BasketItem>>,
687
688 callback_url: Option<String>,
689}
690
691impl CreatePeccoInitializeRequest {
692 pub fn new() -> Self {
693 CreatePeccoInitializeRequest::default()
694 }
695
696 pub fn set_price<S: Into<BigDecimal>>(&mut self, price: S) {
697 self.price = Some(price.into());
698 }
699
700 pub fn set_paid_price<S: Into<BigDecimal>>(&mut self, paid_price: S) {
701 self.paid_price = Some(paid_price.into());
702 }
703
704 pub fn set_basket_id<S: Into<String>>(&mut self, basket_id: S) {
705 self.basket_id = Some(basket_id.into());
706 }
707
708 pub fn set_payment_group<S: Into<String>>(&mut self, payment_group: S) {
709 self.payment_group = Some(payment_group.into());
710 }
711
712 pub fn set_payment_source<S: Into<String>>(&mut self, payment_source: S) {
713 self.payment_source = Some(payment_source.into());
714 }
715
716 pub fn set_currency<S: Into<String>>(&mut self, currency: S) {
717 self.currency = Some(currency.into());
718 }
719
720 pub fn set_buyer(&mut self, buyer: Buyer) {
721 self.buyer = Some(buyer);
722 }
723
724 pub fn set_shipping_address(&mut self, shipping_address: Address) {
725 self.shipping_address = Some(shipping_address);
726 }
727
728 pub fn set_billing_address(&mut self, billing_address: Address) {
729 self.billing_address = Some(billing_address);
730 }
731
732 pub fn set_basket_items(&mut self, basket_items: Vec<BasketItem>) {
733 self.basket_items = Some(basket_items);
734 }
735
736 pub fn set_callback_url<S: Into<String>>(&mut self, callback_url: S) {
737 self.callback_url = Some(callback_url.into());
738 }
739}
740
741impl PKISerialize for CreatePeccoInitializeRequest {
742 fn serialize(&self) -> Option<String> {
743 let mut ser = RequestStringBuilder::new();
744 ser.append_option_val(self.request.serialize());
745 ser.append_price_option("price", self.price.as_ref());
746 ser.append_option("basketId", self.basket_id.as_ref());
747 ser.append_option("paymentGroup", self.payment_group.as_ref());
748 ser.append_option("buyer", self.buyer.serialize());
749 ser.append_option("shippingAddress", self.shipping_address.serialize());
750 ser.append_option("billingAddress", self.billing_address.serialize());
751 ser.append_option("basketItems", self.basket_items.serialize());
752 ser.append_option("callbackUrl", self.callback_url.as_ref());
753 ser.append_option("paymentSource", self.payment_source.as_ref());
754 ser.append_price_option("paidPrice", self.paid_price.as_ref());
755 Some(ser.build(true))
756 }
757}
758
759impl std::ops::Deref for CreatePeccoInitializeRequest {
760 type Target = Request;
761 fn deref(&self) -> &Self::Target {
762 &self.request
763 }
764}
765
766impl std::ops::DerefMut for CreatePeccoInitializeRequest {
767 fn deref_mut(&mut self) -> &mut Self::Target {
768 &mut self.request
769 }
770}
771
772#[derive(Debug, Default, Serialize, Deserialize)]
773#[serde(rename_all = "camelCase")]
774pub struct UpdatePaymentItemRequest {
775 #[serde(flatten)]
776 request: Request,
777
778 sub_merchant_key: Option<String>,
779
780 payment_transaction_id: Option<i32>,
781
782 sub_merchant_price: Option<BigDecimal>,
783}
784
785impl UpdatePaymentItemRequest {
786 pub fn new() -> Self {
787 UpdatePaymentItemRequest::default()
788 }
789
790 pub fn set_sub_merchant_key<S: Into<String>>(&mut self, sub_merchant_key: S) {
791 self.sub_merchant_key = Some(sub_merchant_key.into());
792 }
793
794 pub fn set_payment_transaction_id<S: Into<i32>>(&mut self, payment_transaction_id: S) {
795 self.payment_transaction_id = Some(payment_transaction_id.into());
796 }
797
798 pub fn set_sub_merchant_price<S: Into<Option<BigDecimal>>>(&mut self, sub_merchant_price: S) {
799 self.sub_merchant_price = sub_merchant_price.into();
800 }
801}
802
803impl PKISerialize for UpdatePaymentItemRequest {
804 fn serialize(&self) -> Option<String> {
805 let mut ser = RequestStringBuilder::new();
806 ser.append_option_val(self.request.serialize());
807 ser.append_option("subMerchantKey", self.sub_merchant_key.as_ref());
808 ser.append_option("paymentTransactionId", self.payment_transaction_id);
809 ser.append_price_option("subMerchantPrice", self.sub_merchant_price.as_ref());
810 Some(ser.build(true))
811 }
812}
813
814impl std::ops::Deref for UpdatePaymentItemRequest {
815 type Target = Request;
816 fn deref(&self) -> &Self::Target {
817 &self.request
818 }
819}
820
821impl std::ops::DerefMut for UpdatePaymentItemRequest {
822 fn deref_mut(&mut self) -> &mut Self::Target {
823 &mut self.request
824 }
825}
826
827#[derive(Debug, Default, Serialize, Deserialize)]
828#[serde(rename_all = "camelCase")]
829pub struct CreatePeccoPaymentRequest {
830 #[serde(flatten)]
831 request: Request,
832
833 token: Option<String>,
834}
835
836impl CreatePeccoPaymentRequest {
837 pub fn new() -> Self {
838 CreatePeccoPaymentRequest::default()
839 }
840
841 pub fn set_token<S: Into<String>>(&mut self, token: S) {
842 self.token = Some(token.into());
843 }
844}
845
846impl PKISerialize for CreatePeccoPaymentRequest {
847 fn serialize(&self) -> Option<String> {
848 let mut ser = RequestStringBuilder::new();
849 ser.append_option_val(self.request.serialize());
850 ser.append_option_val(self.token.to_owned());
851 Some(ser.build(true))
852 }
853}
854
855impl std::ops::Deref for CreatePeccoPaymentRequest {
856 type Target = Request;
857 fn deref(&self) -> &Self::Target {
858 &self.request
859 }
860}
861
862impl std::ops::DerefMut for CreatePeccoPaymentRequest {
863 fn deref_mut(&mut self) -> &mut Self::Target {
864 &mut self.request
865 }
866}