feat(payment_method_data): populate additional payment method data fields across all the methods in payments response (#5788)

Co-authored-by: hyperswitch-bot[bot] <148525504+hyperswitch-bot[bot]@users.noreply.github.com>
2025-10-28 12:15:40 +08:00 · 2024-09-11 11:30:59 +05:30
parent 75e8f35431
commit 034f736ea6
16 changed files with 2570 additions and 118 deletions
--- a/crates/api_models/src/payments.rs
+++ b/crates/api_models/src/payments.rs
@ -3,7 +3,7 @@ use std::{
    fmt,
    num::NonZeroI64,
 };
-
+pub mod additional_info;
 use cards::CardNumber;
 use common_utils::{
    consts::default_payments_list_limit,
@ -2033,6 +2033,8 @@ pub enum AdditionalPaymentData {
    Card(Box<AdditionalCardInfo>),
    BankRedirect {
        bank_name: Option<common_enums::BankNames>,
+        #[serde(flatten)]
+        details: Option<additional_info::BankRedirectDetails>,
    },
    Wallet {
        apple_pay: Option<ApplepayPaymentMethod>,
@ -2040,18 +2042,48 @@ pub enum AdditionalPaymentData {
    PayLater {
        klarna_sdk: Option<KlarnaSdkPaymentMethod>,
    },
-    BankTransfer {},
-    Crypto {},
-    BankDebit {},
+    BankTransfer {
+        #[serde(flatten)]
+        details: Option<additional_info::BankTransferAdditionalData>,
+    },
+    Crypto {
+        #[serde(flatten)]
+        details: Option<CryptoData>,
+    },
+    BankDebit {
+        #[serde(flatten)]
+        details: Option<additional_info::BankDebitAdditionalData>,
+    },
    MandatePayment {},
    Reward {},
-    RealTimePayment {},
-    Upi {},
-    GiftCard {},
-    Voucher {},
-    CardRedirect {},
-    CardToken {},
-    OpenBanking {},
+    RealTimePayment {
+        #[serde(flatten)]
+        details: Option<RealTimePaymentData>,
+    },
+    Upi {
+        #[serde(flatten)]
+        details: Option<additional_info::UpiAdditionalData>,
+    },
+    GiftCard {
+        #[serde(flatten)]
+        details: Option<additional_info::GiftCardAdditionalData>,
+    },
+    Voucher {
+        #[serde(flatten)]
+        details: Option<VoucherData>,
+    },
+    CardRedirect {
+        #[serde(flatten)]
+        details: Option<CardRedirectData>,
+    },
+    CardToken {
+        #[serde(flatten)]
+        details: Option<additional_info::CardTokenAdditionalData>,
+    },
+    OpenBanking {
+        #[serde(flatten)]
+        details: Option<OpenBankingData>,
+    },
 }

 #[derive(Debug, Clone, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
@ -3018,21 +3050,21 @@ where
        {
            match payment_method_data {
                PaymentMethodDataResponse::Reward {} => serializer.serialize_str("reward"),
-                PaymentMethodDataResponse::BankDebit {}
-                | PaymentMethodDataResponse::BankRedirect {}
+                PaymentMethodDataResponse::BankDebit(_)
+                | PaymentMethodDataResponse::BankRedirect(_)
                | PaymentMethodDataResponse::Card(_)
-                | PaymentMethodDataResponse::CardRedirect {}
-                | PaymentMethodDataResponse::CardToken {}
-                | PaymentMethodDataResponse::Crypto {}
+                | PaymentMethodDataResponse::CardRedirect(_)
+                | PaymentMethodDataResponse::CardToken(_)
+                | PaymentMethodDataResponse::Crypto(_)
                | PaymentMethodDataResponse::MandatePayment {}
-                | PaymentMethodDataResponse::GiftCard {}
+                | PaymentMethodDataResponse::GiftCard(_)
                | PaymentMethodDataResponse::PayLater(_)
-                | PaymentMethodDataResponse::RealTimePayment {}
-                | PaymentMethodDataResponse::Upi {}
+                | PaymentMethodDataResponse::RealTimePayment(_)
+                | PaymentMethodDataResponse::Upi(_)
                | PaymentMethodDataResponse::Wallet {}
-                | PaymentMethodDataResponse::BankTransfer {}
-                | PaymentMethodDataResponse::OpenBanking {}
-                | PaymentMethodDataResponse::Voucher {} => {
+                | PaymentMethodDataResponse::BankTransfer(_)
+                | PaymentMethodDataResponse::OpenBanking(_)
+                | PaymentMethodDataResponse::Voucher(_) => {
                    payment_method_data_response.serialize(serializer)
                }
            }
@ -3048,23 +3080,98 @@ where
 #[derive(Debug, Clone, Eq, PartialEq, serde::Serialize, serde::Deserialize, ToSchema)]
 #[serde(rename_all = "snake_case")]
 pub enum PaymentMethodDataResponse {
-    #[serde(rename = "card")]
    Card(Box<CardResponse>),
-    BankTransfer {},
+    BankTransfer(Box<BankTransferResponse>),
    Wallet {},
    PayLater(Box<PaylaterResponse>),
-    BankRedirect {},
-    Crypto {},
-    BankDebit {},
+    BankRedirect(Box<BankRedirectResponse>),
+    Crypto(Box<CryptoResponse>),
+    BankDebit(Box<BankDebitResponse>),
    MandatePayment {},
    Reward {},
-    RealTimePayment {},
-    Upi {},
-    Voucher {},
-    GiftCard {},
-    CardRedirect {},
-    CardToken {},
-    OpenBanking {},
+    RealTimePayment(Box<RealTimePaymentDataResponse>),
+    Upi(Box<UpiResponse>),
+    Voucher(Box<VoucherResponse>),
+    GiftCard(Box<GiftCardResponse>),
+    CardRedirect(Box<CardRedirectResponse>),
+    CardToken(Box<CardTokenResponse>),
+    OpenBanking(Box<OpenBankingResponse>),
+}
+
+#[derive(Eq, PartialEq, Clone, Debug, serde::Serialize, serde::Deserialize, ToSchema)]
+pub struct BankDebitResponse {
+    #[serde(flatten)]
+    #[schema(value_type = Option<BankDebitAdditionalData>)]
+    details: Option<additional_info::BankDebitAdditionalData>,
+}
+
+#[derive(Eq, PartialEq, Clone, Debug, serde::Deserialize, serde::Serialize, ToSchema)]
+#[serde(rename_all = "snake_case", tag = "type")]
+pub struct BankRedirectResponse {
+    /// Name of the bank
+    #[schema(value_type = Option<BankNames>)]
+    pub bank_name: Option<common_enums::BankNames>,
+    #[serde(flatten)]
+    #[schema(value_type = Option<BankRedirectDetails>)]
+    pub details: Option<additional_info::BankRedirectDetails>,
+}
+
+#[derive(Eq, PartialEq, Clone, Debug, serde::Serialize, serde::Deserialize, ToSchema)]
+pub struct BankTransferResponse {
+    #[serde(flatten)]
+    #[schema(value_type = Option<BankTransferAdditionalData>)]
+    details: Option<additional_info::BankTransferAdditionalData>,
+}
+
+#[derive(Eq, PartialEq, Clone, Debug, serde::Serialize, serde::Deserialize, ToSchema)]
+pub struct CardRedirectResponse {
+    #[serde(flatten)]
+    details: Option<CardRedirectData>,
+}
+
+#[derive(Eq, PartialEq, Clone, Debug, serde::Serialize, serde::Deserialize, ToSchema)]
+pub struct CardTokenResponse {
+    #[serde(flatten)]
+    #[schema(value_type = Option<CardTokenAdditionalData>)]
+    details: Option<additional_info::CardTokenAdditionalData>,
+}
+
+#[derive(Eq, PartialEq, Clone, Debug, serde::Serialize, serde::Deserialize, ToSchema)]
+pub struct CryptoResponse {
+    #[serde(flatten)]
+    details: Option<CryptoData>,
+}
+
+#[derive(Eq, PartialEq, Clone, Debug, serde::Serialize, serde::Deserialize, ToSchema)]
+pub struct GiftCardResponse {
+    #[serde(flatten)]
+    #[schema(value_type = Option<GiftCardAdditionalData>)]
+    details: Option<additional_info::GiftCardAdditionalData>,
+}
+
+#[derive(Eq, PartialEq, Clone, Debug, serde::Serialize, serde::Deserialize, ToSchema)]
+pub struct OpenBankingResponse {
+    #[serde(flatten)]
+    details: Option<OpenBankingData>,
+}
+
+#[derive(Eq, PartialEq, Clone, Debug, serde::Serialize, serde::Deserialize, ToSchema)]
+pub struct RealTimePaymentDataResponse {
+    #[serde(flatten)]
+    details: Option<RealTimePaymentData>,
+}
+
+#[derive(Eq, PartialEq, Clone, Debug, serde::Serialize, serde::Deserialize, ToSchema)]
+pub struct UpiResponse {
+    #[serde(flatten)]
+    #[schema(value_type = Option<UpiAdditionalData>)]
+    details: Option<additional_info::UpiAdditionalData>,
+}
+
+#[derive(Eq, PartialEq, Clone, Debug, serde::Serialize, serde::Deserialize, ToSchema)]
+pub struct VoucherResponse {
+    #[serde(flatten)]
+    details: Option<VoucherData>,
 }

 #[derive(Eq, PartialEq, Clone, Debug, serde::Serialize, serde::Deserialize, ToSchema)]
@ -4306,19 +4413,39 @@ impl From<AdditionalPaymentData> for PaymentMethodDataResponse {
                None => Self::PayLater(Box::new(PaylaterResponse { klarna_sdk: None })),
            },
            AdditionalPaymentData::Wallet { .. } => Self::Wallet {},
-            AdditionalPaymentData::BankRedirect { .. } => Self::BankRedirect {},
-            AdditionalPaymentData::Crypto {} => Self::Crypto {},
-            AdditionalPaymentData::BankDebit {} => Self::BankDebit {},
+            AdditionalPaymentData::BankRedirect { bank_name, details } => {
+                Self::BankRedirect(Box::new(BankRedirectResponse { bank_name, details }))
+            }
+            AdditionalPaymentData::Crypto { details } => {
+                Self::Crypto(Box::new(CryptoResponse { details }))
+            }
+            AdditionalPaymentData::BankDebit { details } => {
+                Self::BankDebit(Box::new(BankDebitResponse { details }))
+            }
            AdditionalPaymentData::MandatePayment {} => Self::MandatePayment {},
            AdditionalPaymentData::Reward {} => Self::Reward {},
-            AdditionalPaymentData::RealTimePayment {} => Self::RealTimePayment {},
-            AdditionalPaymentData::Upi {} => Self::Upi {},
-            AdditionalPaymentData::BankTransfer {} => Self::BankTransfer {},
-            AdditionalPaymentData::Voucher {} => Self::Voucher {},
-            AdditionalPaymentData::GiftCard {} => Self::GiftCard {},
-            AdditionalPaymentData::CardRedirect {} => Self::CardRedirect {},
-            AdditionalPaymentData::CardToken {} => Self::CardToken {},
-            AdditionalPaymentData::OpenBanking {} => Self::OpenBanking {},
+            AdditionalPaymentData::RealTimePayment { details } => {
+                Self::RealTimePayment(Box::new(RealTimePaymentDataResponse { details }))
+            }
+            AdditionalPaymentData::Upi { details } => Self::Upi(Box::new(UpiResponse { details })),
+            AdditionalPaymentData::BankTransfer { details } => {
+                Self::BankTransfer(Box::new(BankTransferResponse { details }))
+            }
+            AdditionalPaymentData::Voucher { details } => {
+                Self::Voucher(Box::new(VoucherResponse { details }))
+            }
+            AdditionalPaymentData::GiftCard { details } => {
+                Self::GiftCard(Box::new(GiftCardResponse { details }))
+            }
+            AdditionalPaymentData::CardRedirect { details } => {
+                Self::CardRedirect(Box::new(CardRedirectResponse { details }))
+            }
+            AdditionalPaymentData::CardToken { details } => {
+                Self::CardToken(Box::new(CardTokenResponse { details }))
+            }
+            AdditionalPaymentData::OpenBanking { details } => {
+                Self::OpenBanking(Box::new(OpenBankingResponse { details }))
+            }
        }
    }
 }
--- a/crates/api_models/src/payments/additional_info.rs
+++ b/crates/api_models/src/payments/additional_info.rs
@ -0,0 +1,213 @@
+use common_utils::new_type::{
+    MaskedBankAccount, MaskedIban, MaskedRoutingNumber, MaskedSortCode, MaskedUpiVpaId,
+};
+use masking::Secret;
+use utoipa::ToSchema;
+
+use crate::enums as api_enums;
+
+#[derive(Eq, PartialEq, Clone, Debug, serde::Deserialize, serde::Serialize, ToSchema)]
+#[serde(rename_all = "snake_case")]
+pub enum BankDebitAdditionalData {
+    Ach(Box<AchBankDebitAdditionalData>),
+    Bacs(Box<BacsBankDebitAdditionalData>),
+    Becs(Box<BecsBankDebitAdditionalData>),
+    Sepa(Box<SepaBankDebitAdditionalData>),
+}
+
+#[derive(Eq, PartialEq, Clone, Debug, serde::Deserialize, serde::Serialize, ToSchema)]
+pub struct AchBankDebitAdditionalData {
+    /// Partially masked account number for ach bank debit payment
+    #[schema(value_type = String, example = "0001****3456")]
+    pub account_number: MaskedBankAccount,
+
+    /// Partially masked routing number for ach bank debit payment
+    #[schema(value_type = String, example = "110***000")]
+    pub routing_number: MaskedRoutingNumber,
+
+    /// Card holder's name
+    #[schema(value_type = Option<String>, example = "John Doe")]
+    pub card_holder_name: Option<Secret<String>>,
+
+    /// Bank account's owner name
+    #[schema(value_type = Option<String>, example = "John Doe")]
+    pub bank_account_holder_name: Option<Secret<String>>,
+
+    /// Name of the bank
+    #[schema(value_type = Option<BankNames>, example = "ach")]
+    pub bank_name: Option<common_enums::BankNames>,
+
+    /// Bank account type
+    #[schema(value_type = Option<BankType>, example = "checking")]
+    pub bank_type: Option<common_enums::BankType>,
+
+    /// Bank holder entity type
+    #[schema(value_type = Option<BankHolderType>, example = "personal")]
+    pub bank_holder_type: Option<common_enums::BankHolderType>,
+}
+
+#[derive(Eq, PartialEq, Clone, Debug, serde::Deserialize, serde::Serialize, ToSchema)]
+pub struct BacsBankDebitAdditionalData {
+    /// Partially masked account number for Bacs payment method
+    #[schema(value_type = String, example = "0001****3456")]
+    pub account_number: MaskedBankAccount,
+
+    /// Partially masked sort code for Bacs payment method
+    #[schema(value_type = String, example = "108800")]
+    pub sort_code: MaskedSortCode,
+
+    /// Bank account's owner name
+    #[schema(value_type = Option<String>, example = "John Doe")]
+    pub bank_account_holder_name: Option<Secret<String>>,
+}
+
+#[derive(Eq, PartialEq, Clone, Debug, serde::Deserialize, serde::Serialize, ToSchema)]
+pub struct BecsBankDebitAdditionalData {
+    /// Partially masked account number for Becs payment method
+    #[schema(value_type = String, example = "0001****3456")]
+    pub account_number: MaskedBankAccount,
+
+    /// Bank-State-Branch (bsb) number
+    #[schema(value_type = String, example = "000000")]
+    pub bsb_number: Secret<String>,
+
+    /// Bank account's owner name
+    #[schema(value_type = Option<String>, example = "John Doe")]
+    pub bank_account_holder_name: Option<Secret<String>>,
+}
+
+#[derive(Eq, PartialEq, Clone, Debug, serde::Deserialize, serde::Serialize, ToSchema)]
+pub struct SepaBankDebitAdditionalData {
+    /// Partially masked international bank account number (iban) for SEPA
+    #[schema(value_type = String, example = "DE8937******013000")]
+    pub iban: MaskedIban,
+
+    /// Bank account's owner name
+    #[schema(value_type = Option<String>, example = "John Doe")]
+    pub bank_account_holder_name: Option<Secret<String>>,
+}
+
+#[derive(Eq, PartialEq, Clone, Debug, serde::Deserialize, serde::Serialize, ToSchema)]
+pub enum BankRedirectDetails {
+    BancontactCard(Box<BancontactBankRedirectAdditionalData>),
+    Blik(Box<BlikBankRedirectAdditionalData>),
+    Giropay(Box<GiropayBankRedirectAdditionalData>),
+}
+
+#[derive(Eq, PartialEq, Clone, Debug, serde::Deserialize, serde::Serialize, ToSchema)]
+pub struct BancontactBankRedirectAdditionalData {
+    /// Last 4 digits of the card number
+    #[schema(value_type = Option<String>, example = "4242")]
+    pub last4: Option<String>,
+
+    /// The card's expiry month
+    #[schema(value_type = Option<String>, example = "12")]
+    pub card_exp_month: Option<Secret<String>>,
+
+    /// The card's expiry year
+    #[schema(value_type = Option<String>, example = "24")]
+    pub card_exp_year: Option<Secret<String>>,
+
+    /// The card holder's name
+    #[schema(value_type = Option<String>, example = "John Test")]
+    pub card_holder_name: Option<Secret<String>>,
+}
+
+#[derive(Eq, PartialEq, Clone, Debug, serde::Deserialize, serde::Serialize, ToSchema)]
+pub struct BlikBankRedirectAdditionalData {
+    #[schema(value_type = Option<String>, example = "3GD9MO")]
+    pub blik_code: Option<String>,
+}
+
+#[derive(Eq, PartialEq, Clone, Debug, serde::Deserialize, serde::Serialize, ToSchema)]
+pub struct GiropayBankRedirectAdditionalData {
+    #[schema(value_type = Option<String>)]
+    /// Masked bank account bic code
+    pub bic: Option<MaskedSortCode>,
+
+    /// Partially masked international bank account number (iban) for SEPA
+    #[schema(value_type = Option<String>)]
+    pub iban: Option<MaskedIban>,
+
+    /// Country for bank payment
+    #[schema(value_type = Option<CountryAlpha2>, example = "US")]
+    pub country: Option<api_enums::CountryAlpha2>,
+}
+
+#[derive(Eq, PartialEq, Clone, Debug, serde::Deserialize, serde::Serialize, ToSchema)]
+#[serde(rename_all = "snake_case")]
+pub enum BankTransferAdditionalData {
+    Ach {},
+    Sepa {},
+    Bacs {},
+    Multibanco {},
+    Permata {},
+    Bca {},
+    BniVa {},
+    BriVa {},
+    CimbVa {},
+    DanamonVa {},
+    MandiriVa {},
+    Pix(Box<PixBankTransferAdditionalData>),
+    Pse {},
+    LocalBankTransfer(Box<LocalBankTransferAdditionalData>),
+}
+
+#[derive(Eq, PartialEq, Clone, Debug, serde::Deserialize, serde::Serialize, ToSchema)]
+pub struct PixBankTransferAdditionalData {
+    /// Partially masked unique key for pix transfer
+    #[schema(value_type = Option<String>, example = "a1f4102e ****** 6fa48899c1d1")]
+    pub pix_key: Option<MaskedBankAccount>,
+
+    /// Partially masked CPF - CPF is a Brazilian tax identification number
+    #[schema(value_type = Option<String>, example = "**** 124689")]
+    pub cpf: Option<MaskedBankAccount>,
+
+    /// Partially masked CNPJ - CNPJ is a Brazilian company tax identification number
+    #[schema(value_type = Option<String>, example = "**** 417312")]
+    pub cnpj: Option<MaskedBankAccount>,
+}
+
+#[derive(Eq, PartialEq, Clone, Debug, serde::Deserialize, serde::Serialize, ToSchema)]
+pub struct LocalBankTransferAdditionalData {
+    /// Partially masked bank code
+    #[schema(value_type = Option<String>, example = "**** OA2312")]
+    pub bank_code: Option<MaskedBankAccount>,
+}
+
+#[derive(Eq, PartialEq, Clone, Debug, serde::Deserialize, serde::Serialize, ToSchema)]
+#[serde(rename_all = "snake_case")]
+pub enum GiftCardAdditionalData {
+    Givex(Box<GivexGiftCardAdditionalData>),
+    PaySafeCard {},
+}
+
+#[derive(Eq, PartialEq, Clone, Debug, serde::Deserialize, serde::Serialize, ToSchema)]
+pub struct GivexGiftCardAdditionalData {
+    /// Last 4 digits of the gift card number
+    #[schema(value_type = String, example = "4242")]
+    pub last4: Secret<String>,
+}
+
+#[derive(Eq, PartialEq, Clone, Debug, serde::Deserialize, serde::Serialize, ToSchema)]
+pub struct CardTokenAdditionalData {
+    /// The card holder's name
+    #[schema(value_type = String, example = "John Test")]
+    pub card_holder_name: Option<Secret<String>>,
+}
+
+#[derive(Debug, Clone, Eq, PartialEq, serde::Deserialize, serde::Serialize, ToSchema)]
+#[serde(rename_all = "snake_case")]
+pub enum UpiAdditionalData {
+    UpiCollect(Box<UpiCollectAdditionalData>),
+    #[schema(value_type = UpiIntentData)]
+    UpiIntent(Box<super::UpiIntentData>),
+}
+
+#[derive(Debug, Clone, Eq, PartialEq, serde::Deserialize, serde::Serialize, ToSchema)]
+#[serde(rename_all = "snake_case")]
+pub struct UpiCollectAdditionalData {
+    /// Masked VPA ID
+    #[schema(value_type = Option<String>, example = "ab********@okhdfcbank")]
+    pub vpa_id: Option<MaskedUpiVpaId>,
+}