diff --git a/Cargo.lock b/Cargo.lock index f0026e2d29..ea92a99a2c 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -5477,10 +5477,15 @@ checksum = "8835116a5c179084a830efb3adc117ab007512b535bc1a21c991d3b32a6b44dd" name = "payment_methods" version = "0.1.0" dependencies = [ + "api_models", "async-trait", "common_utils", "dyn-clone", "hyperswitch_domain_models", + "hyperswitch_interfaces", + "masking", + "serde", + "serde_json", "storage_impl", ] diff --git a/crates/payment_methods/Cargo.toml b/crates/payment_methods/Cargo.toml index 409e445d7f..db8fe23ba7 100644 --- a/crates/payment_methods/Cargo.toml +++ b/crates/payment_methods/Cargo.toml @@ -8,16 +8,22 @@ license.workspace = true [dependencies] async-trait = "0.1.79" dyn-clone = "1.0.17" +masking = { version = "0.1.0", path = "../masking" } +serde = { version = "1.0.197", features = ["derive"] } +serde_json = "1.0.115" +api_models = { version = "0.1.0", path = "../api_models", features = ["errors", "control_center_theme"] } common_utils = { version = "0.1.0", path = "../common_utils", features = ["signals", "async_ext", "logs", "metrics", "keymanager", "encryption_service"] } hyperswitch_domain_models = { version = "0.1.0", path = "../hyperswitch_domain_models", default-features = false } storage_impl = { version = "0.1.0", path = "../storage_impl", default-features = false } +hyperswitch_interfaces = { version = "0.1.0", path = "../hyperswitch_interfaces", default-features = false } [lints] workspace = true [features] -default = ["v1"] +default = ["v1", "dummy_connector"] v1 = ["hyperswitch_domain_models/v1", "storage_impl/v1", "common_utils/v1"] v2 = [ "payment_methods_v2"] -payment_methods_v2 = [ "hyperswitch_domain_models/payment_methods_v2", "storage_impl/payment_methods_v2", "common_utils/payment_methods_v2"] \ No newline at end of file +payment_methods_v2 = [ "hyperswitch_domain_models/payment_methods_v2", "storage_impl/payment_methods_v2", "common_utils/payment_methods_v2"] +dummy_connector = ["api_models/dummy_connector", "hyperswitch_interfaces/dummy_connector"] \ No newline at end of file diff --git a/crates/payment_methods/src/configs.rs b/crates/payment_methods/src/configs.rs new file mode 100644 index 0000000000..40e55c1d7b --- /dev/null +++ b/crates/payment_methods/src/configs.rs @@ -0,0 +1,2 @@ +pub mod payment_connector_required_fields; +pub mod settings; diff --git a/crates/payment_methods/src/configs/payment_connector_required_fields.rs b/crates/payment_methods/src/configs/payment_connector_required_fields.rs new file mode 100644 index 0000000000..175b82192b --- /dev/null +++ b/crates/payment_methods/src/configs/payment_connector_required_fields.rs @@ -0,0 +1,3306 @@ +use std::collections::{HashMap, HashSet}; + +use api_models::{ + enums::{self, Connector, FieldType}, + payment_methods::RequiredFieldInfo, +}; + +use crate::configs::settings::{ + ConnectorFields, Mandates, PaymentMethodType, RequiredFieldFinal, RequiredFields, + SupportedConnectorsForMandate, SupportedPaymentMethodTypesForMandate, + SupportedPaymentMethodsForMandate, ZeroMandates, +}; + +impl Default for ZeroMandates { + fn default() -> Self { + Self { + supported_payment_methods: SupportedPaymentMethodsForMandate(HashMap::new()), + } + } +} + +impl Default for Mandates { + fn default() -> Self { + Self { + supported_payment_methods: SupportedPaymentMethodsForMandate(HashMap::from([ + ( + enums::PaymentMethod::PayLater, + SupportedPaymentMethodTypesForMandate(HashMap::from([( + enums::PaymentMethodType::Klarna, + SupportedConnectorsForMandate { + connector_list: HashSet::from([Connector::Adyen]), + }, + )])), + ), + ( + enums::PaymentMethod::Wallet, + SupportedPaymentMethodTypesForMandate(HashMap::from([ + ( + enums::PaymentMethodType::GooglePay, + SupportedConnectorsForMandate { + connector_list: HashSet::from([ + Connector::Stripe, + Connector::Adyen, + Connector::Globalpay, + Connector::Multisafepay, + Connector::Bankofamerica, + Connector::Novalnet, + Connector::Noon, + Connector::Cybersource, + Connector::Wellsfargo, + ]), + }, + ), + ( + enums::PaymentMethodType::ApplePay, + SupportedConnectorsForMandate { + connector_list: HashSet::from([ + Connector::Stripe, + Connector::Adyen, + Connector::Bankofamerica, + Connector::Cybersource, + Connector::Novalnet, + Connector::Wellsfargo, + ]), + }, + ), + ( + enums::PaymentMethodType::SamsungPay, + SupportedConnectorsForMandate { + connector_list: HashSet::from([Connector::Cybersource]), + }, + ), + ])), + ), + ( + enums::PaymentMethod::Card, + SupportedPaymentMethodTypesForMandate(HashMap::from([ + ( + enums::PaymentMethodType::Credit, + SupportedConnectorsForMandate { + connector_list: HashSet::from([ + Connector::Aci, + Connector::Adyen, + Connector::Authorizedotnet, + Connector::Globalpay, + Connector::Worldpay, + Connector::Fiuu, + Connector::Multisafepay, + Connector::Nexinets, + Connector::Noon, + Connector::Novalnet, + Connector::Payme, + Connector::Stripe, + Connector::Bankofamerica, + Connector::Cybersource, + Connector::Wellsfargo, + ]), + }, + ), + ( + enums::PaymentMethodType::Debit, + SupportedConnectorsForMandate { + connector_list: HashSet::from([ + Connector::Aci, + Connector::Adyen, + Connector::Authorizedotnet, + Connector::Globalpay, + Connector::Worldpay, + Connector::Fiuu, + Connector::Multisafepay, + Connector::Nexinets, + Connector::Noon, + Connector::Novalnet, + Connector::Payme, + Connector::Stripe, + ]), + }, + ), + ])), + ), + ])), + update_mandate_supported: SupportedPaymentMethodsForMandate(HashMap::default()), + } + } +} + +#[derive(Clone, serde::Serialize)] +enum RequiredField { + CardNumber, + CardExpMonth, + CardExpYear, + CardCvc, + CardNetwork, + BillingUserFirstName, + BillingUserLastName, + /// display name and field type for billing first name + BillingFirstName(&'static str, FieldType), + /// display name and field type for billing last name + BillingLastName(&'static str, FieldType), + BillingEmail, + Email, + BillingPhone, + BillingPhoneCountryCode, + BillingAddressLine1, + BillingAddressLine2, + BillingAddressCity, + BillingAddressState, + BillingAddressZip, + BillingCountries(Vec<&'static str>), + BillingAddressCountries(Vec<&'static str>), + ShippingFirstName, + ShippingLastName, + ShippingAddressCity, + ShippingAddressState, + ShippingAddressZip, + ShippingCountries(Vec<&'static str>), + ShippingAddressCountries(Vec<&'static str>), + ShippingAddressLine1, + ShippingAddressLine2, + ShippingPhone, + ShippingPhoneCountryCode, + ShippingEmail, + OpenBankingUkIssuer, + OpenBankingCzechRepublicIssuer, + OpenBankingPolandIssuer, + OpenBankingSlovakiaIssuer, + OpenBankingFpxIssuer, + OpenBankingThailandIssuer, + BanContactCardNumber, + BanContactCardExpMonth, + BanContactCardExpYear, + IdealBankName, + EpsBankName, + BlikCode, + MifinityDateOfBirth, + MifinityLanguagePreference(Vec<&'static str>), + CryptoNetwork, + CyptoPayCurrency(Vec<&'static str>), + BoletoSocialSecurityNumber, + UpiCollectVpaId, + AchBankDebitAccountNumber, + AchBankDebitRoutingNumber, + SepaBankDebitIban, + BacsBankDebitAccountNumber, + BacsBankDebitSortCode, + BecsBankDebitAccountNumber, + BecsBankDebitBsbNumber, + BecsBankDebitSortCode, + PixKey, + PixCnpj, + PixCpf, + GiftCardNumber, + GiftCardCvc, + DcbMsisdn, + DcbClientUid, + OrderDetailsProductName, +} + +impl RequiredField { + fn to_tuple(&self) -> (String, RequiredFieldInfo) { + match self { + Self::CardNumber => ( + "payment_method_data.card.card_number".to_string(), + RequiredFieldInfo { + required_field: "payment_method_data.card.card_number".to_string(), + display_name: "card_number".to_string(), + field_type: FieldType::UserCardNumber, + value: None, + }, + ), + Self::CardExpMonth => ( + "payment_method_data.card.card_exp_month".to_string(), + RequiredFieldInfo { + required_field: "payment_method_data.card.card_exp_month".to_string(), + display_name: "card_exp_month".to_string(), + field_type: FieldType::UserCardExpiryMonth, + value: None, + }, + ), + Self::CardExpYear => ( + "payment_method_data.card.card_exp_year".to_string(), + RequiredFieldInfo { + required_field: "payment_method_data.card.card_exp_year".to_string(), + display_name: "card_exp_year".to_string(), + field_type: FieldType::UserCardExpiryYear, + value: None, + }, + ), + Self::CardCvc => ( + "payment_method_data.card.card_cvc".to_string(), + RequiredFieldInfo { + required_field: "payment_method_data.card.card_cvc".to_string(), + display_name: "card_cvc".to_string(), + field_type: FieldType::UserCardCvc, + value: None, + }, + ), + Self::CardNetwork => ( + "payment_method_data.card.card_network".to_string(), + RequiredFieldInfo { + required_field: "payment_method_data.card.card_network".to_string(), + display_name: "card_network".to_string(), + field_type: FieldType::UserCardNetwork, + value: None, + }, + ), + Self::BillingUserFirstName => ( + "billing.address.first_name".to_string(), + RequiredFieldInfo { + required_field: "payment_method_data.billing.address.first_name".to_string(), + display_name: "card_holder_name".to_string(), + field_type: FieldType::UserFullName, + value: None, + }, + ), + Self::BillingUserLastName => ( + "billing.address.last_name".to_string(), + RequiredFieldInfo { + required_field: "payment_method_data.billing.address.last_name".to_string(), + display_name: "card_holder_name".to_string(), + field_type: FieldType::UserFullName, + value: None, + }, + ), + Self::BillingFirstName(display_name, field_type) => ( + "billing.address.first_name".to_string(), + RequiredFieldInfo { + required_field: "payment_method_data.billing.address.first_name".to_string(), + display_name: display_name.to_string(), + field_type: field_type.clone(), + value: None, + }, + ), + Self::BillingLastName(display_name, field_type) => ( + "billing.address.last_name".to_string(), + RequiredFieldInfo { + required_field: "payment_method_data.billing.address.last_name".to_string(), + display_name: display_name.to_string(), + field_type: field_type.clone(), + value: None, + }, + ), + Self::Email => ( + "email".to_string(), + RequiredFieldInfo { + required_field: "email".to_string(), + display_name: "email".to_string(), + field_type: FieldType::UserEmailAddress, + value: None, + }, + ), + Self::BillingEmail => ( + "billing.email".to_string(), + RequiredFieldInfo { + required_field: "payment_method_data.billing.email".to_string(), + display_name: "email".to_string(), + field_type: FieldType::UserEmailAddress, + value: None, + }, + ), + Self::BillingPhone => ( + "billing.phone.number".to_string(), + RequiredFieldInfo { + required_field: "payment_method_data.billing.phone.number".to_string(), + display_name: "phone".to_string(), + field_type: FieldType::UserPhoneNumber, + value: None, + }, + ), + Self::BillingPhoneCountryCode => ( + "billing.phone.country_code".to_string(), + RequiredFieldInfo { + required_field: "payment_method_data.billing.phone.country_code".to_string(), + display_name: "dialing_code".to_string(), + field_type: FieldType::UserPhoneNumberCountryCode, + value: None, + }, + ), + Self::BillingAddressLine1 => ( + "billing.address.line1".to_string(), + RequiredFieldInfo { + required_field: "payment_method_data.billing.address.line1".to_string(), + display_name: "line1".to_string(), + field_type: FieldType::UserAddressLine1, + value: None, + }, + ), + Self::BillingAddressLine2 => ( + "billing.address.line2".to_string(), + RequiredFieldInfo { + required_field: "payment_method_data.billing.address.line2".to_string(), + display_name: "line2".to_string(), + field_type: FieldType::UserAddressLine2, + value: None, + }, + ), + Self::BillingAddressCity => ( + "billing.address.city".to_string(), + RequiredFieldInfo { + required_field: "payment_method_data.billing.address.city".to_string(), + display_name: "city".to_string(), + field_type: FieldType::UserAddressCity, + value: None, + }, + ), + Self::BillingAddressState => ( + "billing.address.state".to_string(), + RequiredFieldInfo { + required_field: "payment_method_data.billing.address.state".to_string(), + display_name: "state".to_string(), + field_type: FieldType::UserAddressState, + value: None, + }, + ), + Self::BillingAddressZip => ( + "billing.address.zip".to_string(), + RequiredFieldInfo { + required_field: "payment_method_data.billing.address.zip".to_string(), + display_name: "zip".to_string(), + field_type: FieldType::UserAddressPincode, + value: None, + }, + ), + Self::BillingCountries(countries) => ( + "billing.address.country".to_string(), + RequiredFieldInfo { + required_field: "payment_method_data.billing.address.country".to_string(), + display_name: "country".to_string(), + field_type: FieldType::UserCountry { + options: countries.iter().map(|c| c.to_string()).collect(), + }, + value: None, + }, + ), + Self::BillingAddressCountries(countries) => ( + "billing.address.country".to_string(), + RequiredFieldInfo { + required_field: "payment_method_data.billing.address.country".to_string(), + display_name: "country".to_string(), + field_type: FieldType::UserAddressCountry { + options: countries.iter().map(|c| c.to_string()).collect(), + }, + value: None, + }, + ), + Self::ShippingFirstName => ( + "shipping.address.first_name".to_string(), + RequiredFieldInfo { + required_field: "shipping.address.first_name".to_string(), + display_name: "shipping_first_name".to_string(), + field_type: FieldType::UserShippingName, + value: None, + }, + ), + Self::ShippingLastName => ( + "shipping.address.last_name".to_string(), + RequiredFieldInfo { + required_field: "shipping.address.last_name".to_string(), + display_name: "shipping_last_name".to_string(), + field_type: FieldType::UserShippingName, + value: None, + }, + ), + Self::ShippingAddressCity => ( + "shipping.address.city".to_string(), + RequiredFieldInfo { + required_field: "shipping.address.city".to_string(), + display_name: "city".to_string(), + field_type: FieldType::UserShippingAddressCity, + value: None, + }, + ), + Self::ShippingAddressState => ( + "shipping.address.state".to_string(), + RequiredFieldInfo { + required_field: "shipping.address.state".to_string(), + display_name: "state".to_string(), + field_type: FieldType::UserShippingAddressState, + value: None, + }, + ), + Self::ShippingAddressZip => ( + "shipping.address.zip".to_string(), + RequiredFieldInfo { + required_field: "shipping.address.zip".to_string(), + display_name: "zip".to_string(), + field_type: FieldType::UserShippingAddressPincode, + value: None, + }, + ), + Self::ShippingCountries(countries) => ( + "shipping.address.country".to_string(), + RequiredFieldInfo { + required_field: "shipping.address.country".to_string(), + display_name: "country".to_string(), + field_type: FieldType::UserCountry { + options: countries.iter().map(|c| c.to_string()).collect(), + }, + value: None, + }, + ), + Self::ShippingAddressCountries(countries) => ( + "shipping.address.country".to_string(), + RequiredFieldInfo { + required_field: "shipping.address.country".to_string(), + display_name: "country".to_string(), + field_type: FieldType::UserShippingAddressCountry { + options: countries.iter().map(|c| c.to_string()).collect(), + }, + value: None, + }, + ), + Self::ShippingAddressLine1 => ( + "shipping.address.line1".to_string(), + RequiredFieldInfo { + required_field: "shipping.address.line1".to_string(), + display_name: "line1".to_string(), + field_type: FieldType::UserShippingAddressLine1, + value: None, + }, + ), + Self::ShippingAddressLine2 => ( + "shipping.address.line2".to_string(), + RequiredFieldInfo { + required_field: "shipping.address.line2".to_string(), + display_name: "line2".to_string(), + field_type: FieldType::UserShippingAddressLine2, + value: None, + }, + ), + Self::ShippingPhone => ( + "shipping.phone.number".to_string(), + RequiredFieldInfo { + required_field: "shipping.phone.number".to_string(), + display_name: "phone_number".to_string(), + field_type: FieldType::UserPhoneNumber, + value: None, + }, + ), + Self::ShippingPhoneCountryCode => ( + "shipping.phone.country_code".to_string(), + RequiredFieldInfo { + required_field: "shipping.phone.country_code".to_string(), + display_name: "dialing_code".to_string(), + field_type: FieldType::UserPhoneNumberCountryCode, + value: None, + }, + ), + Self::ShippingEmail => ( + "shipping.email".to_string(), + RequiredFieldInfo { + required_field: "shipping.email".to_string(), + display_name: "email".to_string(), + field_type: FieldType::UserEmailAddress, + value: None, + }, + ), + Self::OpenBankingUkIssuer => ( + "payment_method_data.bank_redirect.open_banking_uk.issuer".to_string(), + RequiredFieldInfo { + required_field: "payment_method_data.bank_redirect.open_banking_uk.issuer" + .to_string(), + display_name: "issuer".to_string(), + field_type: FieldType::UserBank, + value: None, + }, + ), + Self::OpenBankingCzechRepublicIssuer => ( + "payment_method_data.bank_redirect.open_banking_czech_republic.issuer".to_string(), + RequiredFieldInfo { + required_field: + "payment_method_data.bank_redirect.open_banking_czech_republic.issuer" + .to_string(), + display_name: "issuer".to_string(), + field_type: FieldType::UserBank, + value: None, + }, + ), + Self::OpenBankingPolandIssuer => ( + "payment_method_data.bank_redirect.open_banking_poland.issuer".to_string(), + RequiredFieldInfo { + required_field: "payment_method_data.bank_redirect.open_banking_poland.issuer" + .to_string(), + display_name: "issuer".to_string(), + field_type: FieldType::UserBank, + value: None, + }, + ), + Self::OpenBankingSlovakiaIssuer => ( + "payment_method_data.bank_redirect.open_banking_slovakia.issuer".to_string(), + RequiredFieldInfo { + required_field: + "payment_method_data.bank_redirect.open_banking_slovakia.issuer".to_string(), + display_name: "issuer".to_string(), + field_type: FieldType::UserBank, + value: None, + }, + ), + Self::OpenBankingFpxIssuer => ( + "payment_method_data.bank_redirect.open_banking_fpx.issuer".to_string(), + RequiredFieldInfo { + required_field: "payment_method_data.bank_redirect.open_banking_fpx.issuer" + .to_string(), + display_name: "issuer".to_string(), + field_type: FieldType::UserBank, + value: None, + }, + ), + Self::OpenBankingThailandIssuer => ( + "payment_method_data.bank_redirect.open_banking_thailand.issuer".to_string(), + RequiredFieldInfo { + required_field: + "payment_method_data.bank_redirect.open_banking_thailand.issuer".to_string(), + display_name: "issuer".to_string(), + field_type: FieldType::UserBank, + value: None, + }, + ), + Self::BanContactCardNumber => ( + "payment_method_data.bank_redirect.bancontact_card.card_number".to_string(), + RequiredFieldInfo { + required_field: "payment_method_data.bank_redirect.bancontact_card.card_number" + .to_string(), + display_name: "card_number".to_string(), + field_type: FieldType::UserCardNumber, + value: None, + }, + ), + Self::BanContactCardExpMonth => ( + "payment_method_data.bank_redirect.bancontact_card.card_exp_month".to_string(), + RequiredFieldInfo { + required_field: + "payment_method_data.bank_redirect.bancontact_card.card_exp_month" + .to_string(), + display_name: "card_exp_month".to_string(), + field_type: FieldType::UserCardExpiryMonth, + value: None, + }, + ), + Self::BanContactCardExpYear => ( + "payment_method_data.bank_redirect.bancontact_card.card_exp_year".to_string(), + RequiredFieldInfo { + required_field: + "payment_method_data.bank_redirect.bancontact_card.card_exp_year" + .to_string(), + display_name: "card_exp_year".to_string(), + field_type: FieldType::UserCardExpiryYear, + value: None, + }, + ), + Self::IdealBankName => ( + "payment_method_data.bank_redirect.ideal.bank_name".to_string(), + RequiredFieldInfo { + required_field: "payment_method_data.bank_redirect.ideal.bank_name".to_string(), + display_name: "bank_name".to_string(), + field_type: FieldType::UserBank, + value: None, + }, + ), + Self::EpsBankName => ( + "payment_method_data.bank_redirect.eps.bank_name".to_string(), + RequiredFieldInfo { + required_field: "payment_method_data.bank_redirect.eps.bank_name".to_string(), + display_name: "bank_name".to_string(), + field_type: FieldType::UserBank, + value: None, + }, + ), + Self::BlikCode => ( + "payment_method_data.bank_redirect.blik.blik_code".to_string(), + RequiredFieldInfo { + required_field: "payment_method_data.bank_redirect.blik.blik_code".to_string(), + display_name: "blik_code".to_string(), + field_type: FieldType::UserBlikCode, + value: None, + }, + ), + Self::MifinityDateOfBirth => ( + "payment_method_data.wallet.mifinity.date_of_birth".to_string(), + RequiredFieldInfo { + required_field: "payment_method_data.wallet.mifinity.date_of_birth".to_string(), + display_name: "date_of_birth".to_string(), + field_type: FieldType::UserDateOfBirth, + value: None, + }, + ), + Self::MifinityLanguagePreference(languages) => ( + "payment_method_data.wallet.mifinity.language_preference".to_string(), + RequiredFieldInfo { + required_field: "payment_method_data.wallet.mifinity.language_preference" + .to_string(), + display_name: "language_preference".to_string(), + field_type: FieldType::LanguagePreference { + options: languages.iter().map(|l| l.to_string()).collect(), + }, + value: None, + }, + ), + Self::CryptoNetwork => ( + "payment_method_data.crypto.network".to_string(), + RequiredFieldInfo { + required_field: "payment_method_data.crypto.network".to_string(), + display_name: "network".to_string(), + field_type: FieldType::UserCryptoCurrencyNetwork, + value: None, + }, + ), + Self::CyptoPayCurrency(currencies) => ( + "payment_method_data.crypto.pay_currency".to_string(), + RequiredFieldInfo { + required_field: "payment_method_data.crypto.pay_currency".to_string(), + display_name: "currency".to_string(), + field_type: FieldType::UserCurrency { + options: currencies.iter().map(|c| c.to_string()).collect(), + }, + value: None, + }, + ), + Self::BoletoSocialSecurityNumber => ( + "payment_method_data.voucher.boleto.social_security_number".to_string(), + RequiredFieldInfo { + required_field: "payment_method_data.voucher.boleto.social_security_number" + .to_string(), + display_name: "social_security_number".to_string(), + field_type: FieldType::UserSocialSecurityNumber, + value: None, + }, + ), + Self::UpiCollectVpaId => ( + "payment_method_data.upi.upi_collect.vpa_id".to_string(), + RequiredFieldInfo { + required_field: "payment_method_data.upi.upi_collect.vpa_id".to_string(), + display_name: "vpa_id".to_string(), + field_type: FieldType::UserVpaId, + value: None, + }, + ), + Self::AchBankDebitAccountNumber => ( + "payment_method_data.bank_debit.ach_bank_debit.account_number".to_string(), + RequiredFieldInfo { + required_field: "payment_method_data.bank_debit.ach_bank_debit.account_number" + .to_string(), + display_name: "bank_account_number".to_string(), + field_type: FieldType::UserBankAccountNumber, + value: None, + }, + ), + Self::AchBankDebitRoutingNumber => ( + "payment_method_data.bank_debit.ach_bank_debit.routing_number".to_string(), + RequiredFieldInfo { + required_field: "payment_method_data.bank_debit.ach_bank_debit.routing_number" + .to_string(), + display_name: "bank_routing_number".to_string(), + field_type: FieldType::UserBankRoutingNumber, + value: None, + }, + ), + Self::SepaBankDebitIban => ( + "payment_method_data.bank_debit.sepa_bank_debit.iban".to_string(), + RequiredFieldInfo { + required_field: "payment_method_data.bank_debit.sepa_bank_debit.iban" + .to_string(), + display_name: "iban".to_string(), + field_type: FieldType::UserIban, + value: None, + }, + ), + Self::BacsBankDebitAccountNumber => ( + "payment_method_data.bank_debit.bacs_bank_debit.account_number".to_string(), + RequiredFieldInfo { + required_field: "payment_method_data.bank_debit.bacs_bank_debit.account_number" + .to_string(), + display_name: "bank_account_number".to_string(), + field_type: FieldType::UserBankAccountNumber, + value: None, + }, + ), + Self::BacsBankDebitSortCode => ( + "payment_method_data.bank_debit.bacs_bank_debit.sort_code".to_string(), + RequiredFieldInfo { + required_field: "payment_method_data.bank_debit.bacs_bank_debit.sort_code" + .to_string(), + display_name: "bank_sort_code".to_string(), + field_type: FieldType::UserBankSortCode, + value: None, + }, + ), + Self::BecsBankDebitAccountNumber => ( + "payment_method_data.bank_debit.becs_bank_debit.account_number".to_string(), + RequiredFieldInfo { + required_field: "payment_method_data.bank_debit.becs_bank_debit.account_number" + .to_string(), + display_name: "bank_account_number".to_string(), + field_type: FieldType::UserBankAccountNumber, + value: None, + }, + ), + Self::BecsBankDebitBsbNumber => ( + "payment_method_data.bank_debit.becs_bank_debit.bsb_number".to_string(), + RequiredFieldInfo { + required_field: "payment_method_data.bank_debit.becs_bank_debit.bsb_number" + .to_string(), + display_name: "bsb_number".to_string(), + field_type: FieldType::UserBsbNumber, + value: None, + }, + ), + Self::BecsBankDebitSortCode => ( + "payment_method_data.bank_debit.becs_bank_debit.sort_code".to_string(), + RequiredFieldInfo { + required_field: "payment_method_data.bank_debit.becs_bank_debit.sort_code" + .to_string(), + display_name: "bank_sort_code".to_string(), + field_type: FieldType::UserBankSortCode, + value: None, + }, + ), + Self::PixKey => ( + "payment_method_data.bank_transfer.pix.pix_key".to_string(), + RequiredFieldInfo { + required_field: "payment_method_data.bank_transfer.pix.pix_key".to_string(), + display_name: "pix_key".to_string(), + field_type: FieldType::UserPixKey, + value: None, + }, + ), + Self::PixCnpj => ( + "payment_method_data.bank_transfer.pix.cnpj".to_string(), + RequiredFieldInfo { + required_field: "payment_method_data.bank_transfer.pix.cnpj".to_string(), + display_name: "cnpj".to_string(), + field_type: FieldType::UserCnpj, + value: None, + }, + ), + Self::PixCpf => ( + "payment_method_data.bank_transfer.pix.cpf".to_string(), + RequiredFieldInfo { + required_field: "payment_method_data.bank_transfer.pix.cpf".to_string(), + display_name: "cpf".to_string(), + field_type: FieldType::UserCpf, + value: None, + }, + ), + Self::GiftCardNumber => ( + "payment_method_data.gift_card.number".to_string(), + RequiredFieldInfo { + required_field: "payment_method_data.gift_card.givex.number".to_string(), + display_name: "gift_card_number".to_string(), + field_type: FieldType::UserCardNumber, + value: None, + }, + ), + Self::GiftCardCvc => ( + "payment_method_data.gift_card.cvc".to_string(), + RequiredFieldInfo { + required_field: "payment_method_data.gift_card.givex.cvc".to_string(), + display_name: "gift_card_cvc".to_string(), + field_type: FieldType::UserCardCvc, + value: None, + }, + ), + Self::DcbMsisdn => ( + "payment_method_data.mobile_payment.direct_carrier_billing.msisdn".to_string(), + RequiredFieldInfo { + required_field: + "payment_method_data.mobile_payment.direct_carrier_billing.msisdn" + .to_string(), + display_name: "mobile_number".to_string(), + field_type: FieldType::UserMsisdn, + value: None, + }, + ), + Self::DcbClientUid => ( + "payment_method_data.mobile_payment.direct_carrier_billing.client_uid".to_string(), + RequiredFieldInfo { + required_field: + "payment_method_data.mobile_payment.direct_carrier_billing.client_uid" + .to_string(), + display_name: "client_identifier".to_string(), + field_type: FieldType::UserClientIdentifier, + value: None, + }, + ), + Self::OrderDetailsProductName => ( + "order_details.0.product_name".to_string(), + RequiredFieldInfo { + required_field: "order_details.0.product_name".to_string(), + display_name: "product_name".to_string(), + field_type: FieldType::OrderDetailsProductName, + value: None, + }, + ), + } + } +} + +// Define helper functions for common field groups +fn card_basic() -> Vec { + vec![ + RequiredField::CardNumber, + RequiredField::CardExpMonth, + RequiredField::CardExpYear, + RequiredField::CardCvc, + ] +} + +fn full_name() -> Vec { + vec![ + RequiredField::BillingUserFirstName, + RequiredField::BillingUserLastName, + ] +} + +fn billing_name() -> Vec { + vec![ + RequiredField::BillingFirstName("billing_first_name", FieldType::UserBillingName), + RequiredField::BillingLastName("billing_last_name", FieldType::UserBillingName), + ] +} + +fn email() -> Vec { + [RequiredField::Email].to_vec() +} + +fn billing_email() -> Vec { + [RequiredField::BillingEmail].to_vec() +} + +fn card_with_name() -> Vec { + [card_basic(), full_name()].concat() +} + +fn billing_email_name() -> Vec { + vec![ + RequiredField::BillingEmail, + RequiredField::BillingUserFirstName, + RequiredField::BillingUserLastName, + ] +} + +fn billing_email_name_phone() -> Vec { + vec![ + RequiredField::BillingUserFirstName, + RequiredField::BillingUserLastName, + RequiredField::BillingEmail, + RequiredField::BillingPhone, + RequiredField::BillingPhoneCountryCode, + ] +} + +fn billing_address() -> Vec { + vec![ + RequiredField::BillingAddressCity, + RequiredField::BillingAddressState, + RequiredField::BillingAddressZip, + RequiredField::BillingAddressCountries(vec!["ALL"]), + RequiredField::BillingAddressLine1, + ] +} + +/// Define the mandate, non-mandate, and common required fields for a connector +/// Eg: fields(vec![RequiredField::CardNumber], vec![RequiredField::BillingEmail], vec![RequiredField::BillingAddressCity]) +#[cfg(feature = "v1")] +fn fields( + mandate: Vec, + non_mandate: Vec, + common: Vec, +) -> RequiredFieldFinal { + let mandate_fields: HashMap<_, _> = mandate.iter().map(|f| f.to_tuple()).collect(); + let non_mandate_fields: HashMap<_, _> = non_mandate.iter().map(|f| f.to_tuple()).collect(); + let common_fields: HashMap<_, _> = common.iter().map(|f| f.to_tuple()).collect(); + RequiredFieldFinal { + mandate: mandate_fields, + non_mandate: non_mandate_fields, + common: common_fields, + } +} + +fn connectors(connectors: Vec<(Connector, RequiredFieldFinal)>) -> ConnectorFields { + ConnectorFields { + fields: connectors.into_iter().collect(), + } +} + +pub fn get_billing_required_fields() -> HashMap { + HashMap::from([ + RequiredField::BillingFirstName("billing_first_name", FieldType::UserBillingName) + .to_tuple(), + RequiredField::BillingLastName("billing_last_name", FieldType::UserBillingName).to_tuple(), + RequiredField::BillingAddressCity.to_tuple(), + RequiredField::BillingAddressState.to_tuple(), + RequiredField::BillingAddressZip.to_tuple(), + RequiredField::BillingAddressCountries(vec!["ALL"]).to_tuple(), + RequiredField::BillingAddressLine1.to_tuple(), + RequiredField::BillingAddressLine2.to_tuple(), + RequiredField::BillingPhone.to_tuple(), + RequiredField::BillingPhoneCountryCode.to_tuple(), + RequiredField::BillingEmail.to_tuple(), + ]) +} + +pub fn get_shipping_required_fields() -> HashMap { + HashMap::from([ + RequiredField::ShippingFirstName.to_tuple(), + RequiredField::ShippingLastName.to_tuple(), + RequiredField::ShippingAddressCity.to_tuple(), + RequiredField::ShippingAddressState.to_tuple(), + RequiredField::ShippingAddressZip.to_tuple(), + RequiredField::ShippingAddressCountries(vec!["ALL"]).to_tuple(), + RequiredField::ShippingAddressLine1.to_tuple(), + RequiredField::ShippingPhone.to_tuple(), + RequiredField::ShippingPhoneCountryCode.to_tuple(), + RequiredField::ShippingEmail.to_tuple(), + ]) +} + +#[cfg(feature = "v1")] +impl Default for RequiredFields { + fn default() -> Self { + let cards_required_fields = get_cards_required_fields(); + let mut debit_required_fields = cards_required_fields.clone(); + debit_required_fields.extend(HashMap::from([ + ( + Connector::Bankofamerica, + fields( + vec![], + vec![], + [card_basic(), email(), full_name(), billing_address()].concat(), + ), + ), + ( + Connector::Getnet, + fields( + vec![], + vec![], + [card_basic(), vec![RequiredField::CardNetwork]].concat(), + ), + ), + ])); + Self(HashMap::from([ + ( + enums::PaymentMethod::Card, + PaymentMethodType(HashMap::from([ + ( + enums::PaymentMethodType::Debit, + ConnectorFields { + fields: cards_required_fields.clone(), + }, + ), + ( + enums::PaymentMethodType::Credit, + ConnectorFields { + fields: debit_required_fields.clone(), + }, + ), + ])), + ), + ( + enums::PaymentMethod::BankRedirect, + PaymentMethodType(get_bank_redirect_required_fields()), + ), + ( + enums::PaymentMethod::Wallet, + PaymentMethodType(get_wallet_required_fields()), + ), + ( + enums::PaymentMethod::PayLater, + PaymentMethodType(get_pay_later_required_fields()), + ), + ( + enums::PaymentMethod::Crypto, + PaymentMethodType(HashMap::from([( + enums::PaymentMethodType::CryptoCurrency, + connectors(vec![( + Connector::Cryptopay, + fields( + vec![], + vec![ + RequiredField::CyptoPayCurrency(vec![ + "BTC", "LTC", "ETH", "XRP", "XLM", "BCH", "ADA", "SOL", "SHIB", + "TRX", "DOGE", "BNB", "USDT", "USDC", "DAI", + ]), + RequiredField::CryptoNetwork, + ], + vec![], + ), + )]), + )])), + ), + ( + enums::PaymentMethod::Voucher, + PaymentMethodType(get_voucher_required_fields()), + ), + ( + enums::PaymentMethod::Upi, + PaymentMethodType(HashMap::from([( + enums::PaymentMethodType::UpiCollect, + connectors(vec![( + Connector::Razorpay, + fields(vec![], vec![], vec![RequiredField::UpiCollectVpaId]), + )]), + )])), + ), + ( + enums::PaymentMethod::BankDebit, + PaymentMethodType(get_bank_debit_required_fields()), + ), + ( + enums::PaymentMethod::BankTransfer, + PaymentMethodType(get_bank_transfer_required_fields()), + ), + ( + enums::PaymentMethod::GiftCard, + PaymentMethodType(HashMap::from([ + ( + enums::PaymentMethodType::PaySafeCard, + connectors(vec![(Connector::Adyen, fields(vec![], vec![], vec![]))]), + ), + ( + enums::PaymentMethodType::Givex, + connectors(vec![( + Connector::Adyen, + fields( + vec![], + vec![RequiredField::GiftCardNumber, RequiredField::GiftCardCvc], + vec![], + ), + )]), + ), + ])), + ), + ( + enums::PaymentMethod::CardRedirect, + PaymentMethodType(HashMap::from([ + ( + enums::PaymentMethodType::Benefit, + connectors(vec![( + Connector::Adyen, + fields( + vec![], + vec![ + RequiredField::BillingFirstName( + "first_name", + FieldType::UserFullName, + ), + RequiredField::BillingLastName( + "last_name", + FieldType::UserFullName, + ), + RequiredField::BillingEmail, + RequiredField::BillingPhone, + RequiredField::BillingPhoneCountryCode, + ], + vec![], + ), + )]), + ), + ( + enums::PaymentMethodType::Knet, + connectors(vec![( + Connector::Adyen, + fields( + vec![], + vec![ + RequiredField::BillingFirstName( + "first_name", + FieldType::UserFullName, + ), + RequiredField::BillingLastName( + "last_name", + FieldType::UserFullName, + ), + RequiredField::BillingEmail, + RequiredField::BillingPhone, + RequiredField::BillingPhoneCountryCode, + ], + vec![], + ), + )]), + ), + ( + enums::PaymentMethodType::MomoAtm, + connectors(vec![(Connector::Adyen, fields(vec![], vec![], vec![]))]), + ), + ])), + ), + ( + enums::PaymentMethod::MobilePayment, + PaymentMethodType(HashMap::from([( + enums::PaymentMethodType::DirectCarrierBilling, + connectors(vec![( + Connector::Digitalvirgo, + RequiredFieldFinal { + mandate: HashMap::new(), + non_mandate: HashMap::new(), + common: HashMap::from([ + RequiredField::DcbMsisdn.to_tuple(), + RequiredField::DcbClientUid.to_tuple(), + RequiredField::OrderDetailsProductName.to_tuple(), + ]), + }, + )]), + )])), + ), + ])) + } +} + +#[cfg(feature = "v1")] +fn get_cards_required_fields() -> HashMap { + HashMap::from([ + (Connector::Aci, fields(vec![], vec![], card_with_name())), + (Connector::Adyen, fields(vec![], vec![], card_with_name())), + (Connector::Airwallex, fields(vec![], card_basic(), vec![])), + ( + Connector::Authorizedotnet, + fields(vec![], vec![], card_basic()), + ), + ( + Connector::Bambora, + fields(vec![], [card_with_name(), billing_email()].concat(), vec![]), + ), + ( + Connector::Bankofamerica, + fields( + vec![], + vec![], + [card_basic(), email(), full_name(), billing_address()].concat(), + ), + ), + (Connector::Billwerk, fields(vec![], vec![], card_basic())), + ( + Connector::Bluesnap, + fields( + vec![], + [card_basic(), email(), full_name()].concat(), + vec![], + ), + ), + (Connector::Boku, fields(vec![], vec![], card_basic())), + (Connector::Braintree, fields(vec![], vec![], card_basic())), + (Connector::Checkout, fields(vec![], card_basic(), vec![])), + ( + Connector::Coinbase, + fields(vec![], vec![RequiredField::BillingUserFirstName], vec![]), + ), + ( + Connector::Cybersource, + fields( + vec![], + vec![], + [card_with_name(), billing_email(), billing_address()].concat(), + ), + ), + ( + Connector::Datatrans, + fields(vec![], vec![], [billing_email(), card_with_name()].concat()), + ), + ( + Connector::Deutschebank, + fields( + vec![], + [ + card_basic(), + email(), + billing_address(), + vec![ + RequiredField::BillingFirstName("first_name", FieldType::UserFullName), + RequiredField::BillingLastName("last_name", FieldType::UserFullName), + ], + ] + .concat(), + vec![], + ), + ), + ( + Connector::Dlocal, + fields( + vec![], + [ + card_with_name(), + vec![RequiredField::BillingAddressCountries(vec!["ALL"])], + ] + .concat(), + vec![], + ), + ), + #[cfg(feature = "dummy_connector")] + ( + Connector::DummyConnector1, + fields(vec![], vec![], card_basic()), + ), + #[cfg(feature = "dummy_connector")] + ( + Connector::DummyConnector2, + fields(vec![], vec![], card_basic()), + ), + #[cfg(feature = "dummy_connector")] + ( + Connector::DummyConnector3, + fields(vec![], vec![], card_basic()), + ), + #[cfg(feature = "dummy_connector")] + ( + Connector::DummyConnector4, + fields(vec![], vec![], card_basic()), + ), + #[cfg(feature = "dummy_connector")] + ( + Connector::DummyConnector5, + fields(vec![], vec![], card_basic()), + ), + #[cfg(feature = "dummy_connector")] + ( + Connector::DummyConnector6, + fields(vec![], vec![], card_basic()), + ), + #[cfg(feature = "dummy_connector")] + ( + Connector::DummyConnector7, + fields(vec![], vec![], card_basic()), + ), + ( + Connector::Elavon, + fields(vec![], [card_basic(), billing_email()].concat(), vec![]), + ), + (Connector::Fiserv, fields(vec![], card_basic(), vec![])), + ( + Connector::Fiuu, + fields( + vec![ + RequiredField::BillingEmail, + RequiredField::BillingUserFirstName, + ], + vec![], + card_basic(), + ), + ), + (Connector::Forte, fields(vec![], card_with_name(), vec![])), + (Connector::Globalpay, fields(vec![], vec![], card_basic())), + ( + Connector::Hipay, + fields( + vec![], + vec![], + [ + vec![RequiredField::BillingEmail], + billing_address(), + card_with_name(), + ] + .concat(), + ), + ), + ( + Connector::Helcim, + fields( + vec![], + [ + card_with_name(), + vec![ + RequiredField::BillingAddressZip, + RequiredField::BillingAddressLine1, + ], + ] + .concat(), + vec![], + ), + ), + (Connector::Iatapay, fields(vec![], vec![], vec![])), + (Connector::Mollie, fields(vec![], card_with_name(), vec![])), + (Connector::Moneris, fields(vec![], card_basic(), vec![])), + ( + Connector::Multisafepay, + fields( + vec![], + vec![], + [ + card_with_name(), + vec![ + RequiredField::BillingAddressLine1, + RequiredField::BillingAddressLine2, + RequiredField::BillingAddressCity, + RequiredField::BillingAddressZip, + RequiredField::BillingAddressCountries(vec!["ALL"]), + ], + ] + .concat(), + ), + ), + (Connector::Nexinets, fields(vec![], vec![], card_basic())), + ( + Connector::Nexixpay, + RequiredFieldFinal { + mandate: HashMap::new(), + non_mandate: HashMap::new(), + common: HashMap::from([ + RequiredField::CardNumber.to_tuple(), + RequiredField::CardExpMonth.to_tuple(), + RequiredField::CardExpYear.to_tuple(), + RequiredField::BillingFirstName("first_name", FieldType::UserFullName) + .to_tuple(), + RequiredField::BillingLastName("last_name", FieldType::UserFullName).to_tuple(), + ]), + }, + ), + ( + Connector::Nmi, + fields( + vec![], + [card_with_name(), vec![RequiredField::BillingAddressZip]].concat(), + vec![], + ), + ), + (Connector::Noon, fields(vec![], vec![], card_with_name())), + ( + Connector::Novalnet, + fields( + vec![], + vec![], + [ + vec![ + RequiredField::BillingFirstName("first_name", FieldType::UserFullName), + RequiredField::BillingLastName("last_name", FieldType::UserFullName), + ], + billing_email(), + ] + .concat(), + ), + ), + (Connector::Nuvei, fields(vec![], vec![], card_basic())), + ( + Connector::Paybox, + fields( + vec![], + vec![], + [ + email(), + card_with_name(), + vec![ + RequiredField::BillingAddressLine1, + RequiredField::BillingAddressCity, + RequiredField::BillingAddressZip, + RequiredField::BillingAddressCountries(vec!["ALL"]), + ], + ] + .concat(), + ), + ), + ( + Connector::Payme, + fields(vec![], vec![], [email(), card_with_name()].concat()), + ), + (Connector::Paypal, fields(vec![], card_basic(), vec![])), + (Connector::Payu, fields(vec![], card_basic(), vec![])), + ( + Connector::Powertranz, + fields(vec![], card_with_name(), vec![]), + ), + (Connector::Rapyd, fields(vec![], card_with_name(), vec![])), + (Connector::Redsys, fields(vec![], card_basic(), vec![])), + (Connector::Shift4, fields(vec![], card_basic(), vec![])), + (Connector::Square, fields(vec![], vec![], card_basic())), + (Connector::Stax, fields(vec![], card_with_name(), vec![])), + (Connector::Stripe, fields(vec![], vec![], card_basic())), + ( + Connector::Trustpay, + fields( + vec![], + [ + card_with_name(), + vec![ + RequiredField::BillingAddressLine1, + RequiredField::BillingAddressCity, + RequiredField::BillingAddressZip, + RequiredField::BillingAddressCountries(vec!["ALL"]), + ], + ] + .concat(), + vec![], + ), + ), + (Connector::Tsys, fields(vec![], card_basic(), vec![])), + ( + Connector::Wellsfargo, + fields( + vec![], + vec![], + [card_with_name(), email(), billing_address()].concat(), + ), + ), + ( + Connector::Worldline, + fields( + vec![], + [ + card_basic(), + vec![RequiredField::BillingAddressCountries(vec!["ALL"])], + ] + .concat(), + vec![], + ), + ), + ( + Connector::Worldpay, + fields( + vec![], + vec![], + vec![ + RequiredField::CardNumber, + RequiredField::CardExpMonth, + RequiredField::CardExpYear, + RequiredField::BillingAddressLine1, + RequiredField::BillingAddressCountries(vec![ + "AF", "AU", "AW", "AZ", "BS", "BH", "BD", "BB", "BZ", "BM", "BT", "BO", + "BA", "BW", "BR", "BN", "BG", "BI", "KH", "CA", "CV", "KY", "CL", "CO", + "KM", "CD", "CR", "CZ", "DZ", "DK", "DJ", "ST", "DO", "EC", "EG", "SV", + "ER", "ET", "FK", "FJ", "GM", "GE", "GH", "GI", "GT", "GN", "GY", "HT", + "HN", "HK", "HU", "IS", "IN", "ID", "IR", "IQ", "IE", "IL", "IT", "JM", + "JP", "JO", "KZ", "KE", "KW", "LA", "LB", "LS", "LR", "LY", "LT", "MO", + "MK", "MG", "MW", "MY", "MV", "MR", "MU", "MX", "MD", "MN", "MA", "MZ", + "MM", "NA", "NZ", "NI", "NG", "KP", "NO", "AR", "PK", "PG", "PY", "PE", + "UY", "PH", "PL", "GB", "QA", "OM", "RO", "RU", "RW", "WS", "SG", "ST", + "ZA", "KR", "LK", "SH", "SD", "SR", "SZ", "SE", "CH", "SY", "TW", "TJ", + "TZ", "TH", "TT", "TN", "TR", "UG", "UA", "US", "UZ", "VU", "VE", "VN", + "ZM", "ZW", + ]), + RequiredField::BillingAddressCity, + RequiredField::BillingAddressZip, + ], + ), + ), + ( + Connector::Xendit, + fields( + vec![], + vec![], + [ + card_basic(), + vec![RequiredField::BillingEmail, RequiredField::BillingPhone], + ] + .concat(), + ), + ), + ( + Connector::Zen, + RequiredFieldFinal { + mandate: HashMap::new(), + non_mandate: HashMap::from([ + RequiredField::CardNumber.to_tuple(), + RequiredField::CardExpMonth.to_tuple(), + RequiredField::CardExpYear.to_tuple(), + RequiredField::Email.to_tuple(), + ]), + common: HashMap::new(), + }, + ), + ]) +} + +#[cfg(feature = "v1")] +fn get_bank_redirect_required_fields() -> HashMap { + HashMap::from([ + ( + enums::PaymentMethodType::OpenBankingUk, + connectors(vec![ + (Connector::Volt, fields(vec![], billing_name(), vec![])), + ( + Connector::Adyen, + fields(vec![], vec![RequiredField::OpenBankingUkIssuer], vec![]), + ), + ]), + ), + ( + enums::PaymentMethodType::Trustly, + connectors(vec![(Connector::Adyen, fields(vec![], vec![], vec![]))]), + ), + ( + enums::PaymentMethodType::OnlineBankingCzechRepublic, + connectors(vec![( + Connector::Adyen, + fields( + vec![], + vec![RequiredField::OpenBankingCzechRepublicIssuer], + vec![], + ), + )]), + ), + ( + enums::PaymentMethodType::OnlineBankingFinland, + connectors(vec![( + Connector::Adyen, + fields(vec![], vec![RequiredField::BillingEmail], vec![]), + )]), + ), + ( + enums::PaymentMethodType::OnlineBankingPoland, + connectors(vec![( + Connector::Adyen, + fields( + vec![], + vec![ + RequiredField::OpenBankingPolandIssuer, + RequiredField::BillingEmail, + ], + vec![], + ), + )]), + ), + ( + enums::PaymentMethodType::OnlineBankingSlovakia, + connectors(vec![( + Connector::Adyen, + fields( + vec![], + vec![RequiredField::OpenBankingSlovakiaIssuer], + vec![], + ), + )]), + ), + ( + enums::PaymentMethodType::OnlineBankingFpx, + connectors(vec![( + Connector::Adyen, + fields(vec![], vec![RequiredField::OpenBankingFpxIssuer], vec![]), + )]), + ), + ( + enums::PaymentMethodType::OnlineBankingThailand, + connectors(vec![( + Connector::Adyen, + fields( + vec![], + vec![RequiredField::OpenBankingThailandIssuer], + vec![], + ), + )]), + ), + ( + enums::PaymentMethodType::Bizum, + connectors(vec![(Connector::Adyen, fields(vec![], vec![], vec![]))]), + ), + ( + enums::PaymentMethodType::Przelewy24, + connectors(vec![( + Connector::Stripe, + fields(vec![], vec![RequiredField::BillingEmail], vec![]), + )]), + ), + ( + enums::PaymentMethodType::BancontactCard, + connectors(vec![ + (Connector::Mollie, fields(vec![], vec![], vec![])), + ( + Connector::Stripe, + fields( + vec![RequiredField::BillingEmail], + vec![], + vec![ + RequiredField::BillingFirstName( + "billing_name", + FieldType::UserFullName, + ), + RequiredField::BillingLastName("billing_name", FieldType::UserFullName), + ], + ), + ), + ( + Connector::Adyen, + RequiredFieldFinal { + mandate: HashMap::new(), + non_mandate: HashMap::new(), + common: HashMap::from([ + RequiredField::BanContactCardNumber.to_tuple(), + RequiredField::BanContactCardExpMonth.to_tuple(), + RequiredField::BanContactCardExpYear.to_tuple(), + RequiredField::BillingUserFirstName.to_tuple(), + RequiredField::BillingUserLastName.to_tuple(), + ]), + }, + ), + ]), + ), + ( + enums::PaymentMethodType::Giropay, + connectors(vec![ + ( + Connector::Aci, + fields( + vec![], + vec![RequiredField::BillingCountries(vec!["DE"])], + vec![], + ), + ), + (Connector::Adyen, fields(vec![], vec![], vec![])), + ( + Connector::Globalpay, + fields( + vec![], + vec![], + vec![RequiredField::BillingAddressCountries(vec!["DE"])], + ), + ), + (Connector::Mollie, fields(vec![], vec![], vec![])), + ( + Connector::Nuvei, + RequiredFieldFinal { + mandate: HashMap::new(), + non_mandate: HashMap::from([ + RequiredField::Email.to_tuple(), + RequiredField::BillingFirstName( + "billing_first_name", + FieldType::UserBillingName, + ) + .to_tuple(), + RequiredField::BillingLastName( + "billing_last_name", + FieldType::UserBillingName, + ) + .to_tuple(), + RequiredField::BillingAddressCountries(vec!["DE"]).to_tuple(), + ]), + common: HashMap::new(), + }, + ), + ( + Connector::Paypal, + RequiredFieldFinal { + mandate: HashMap::new(), + non_mandate: HashMap::from([ + RequiredField::BillingCountries(vec!["DE"]).to_tuple(), + RequiredField::BillingFirstName( + "billing_name", + FieldType::UserBillingName, + ) + .to_tuple(), + RequiredField::BillingLastName( + "billing_name", + FieldType::UserBillingName, + ) + .to_tuple(), + ]), + common: HashMap::new(), + }, + ), + ( + Connector::Stripe, + fields( + vec![], + vec![ + RequiredField::BillingFirstName( + "billing_name", + FieldType::UserBillingName, + ), + RequiredField::BillingLastName( + "billing_name", + FieldType::UserBillingName, + ), + ], + vec![], + ), + ), + (Connector::Shift4, fields(vec![], vec![], vec![])), + ( + Connector::Trustpay, + RequiredFieldFinal { + mandate: HashMap::new(), + non_mandate: HashMap::from([ + RequiredField::BillingFirstName( + "billing_first_name", + FieldType::UserBillingName, + ) + .to_tuple(), + RequiredField::BillingAddressLine1.to_tuple(), + RequiredField::BillingAddressCity.to_tuple(), + RequiredField::BillingAddressZip.to_tuple(), + RequiredField::BillingAddressCountries(vec!["DE"]).to_tuple(), + ]), + common: HashMap::new(), + }, + ), + ]), + ), + ( + enums::PaymentMethodType::Ideal, + connectors(vec![ + ( + Connector::Aci, + RequiredFieldFinal { + mandate: HashMap::new(), + non_mandate: HashMap::from([ + RequiredField::IdealBankName.to_tuple(), + RequiredField::BillingCountries(vec!["NL"]).to_tuple(), + ]), + common: HashMap::new(), + }, + ), + ( + Connector::Adyen, + fields(vec![], vec![], vec![RequiredField::IdealBankName]), + ), + (Connector::Globalpay, fields(vec![], vec![], vec![])), + (Connector::Mollie, fields(vec![], vec![], vec![])), + (Connector::Nexinets, fields(vec![], vec![], vec![])), + ( + Connector::Nuvei, + RequiredFieldFinal { + mandate: HashMap::new(), + non_mandate: HashMap::from([ + RequiredField::Email.to_tuple(), + RequiredField::BillingFirstName( + "billing_first_name", + FieldType::UserBillingName, + ) + .to_tuple(), + RequiredField::BillingLastName( + "billing_last_name", + FieldType::UserBillingName, + ) + .to_tuple(), + RequiredField::BillingAddressCountries(vec!["NL"]).to_tuple(), + ]), + common: HashMap::new(), + }, + ), + ( + Connector::Shift4, + fields( + vec![], + vec![RequiredField::BillingCountries(vec!["NL"])], + vec![], + ), + ), + ( + Connector::Paypal, + RequiredFieldFinal { + mandate: HashMap::new(), + non_mandate: HashMap::from([ + RequiredField::BillingFirstName( + "billing_name", + FieldType::UserBillingName, + ) + .to_tuple(), + RequiredField::BillingLastName( + "billing_name", + FieldType::UserBillingName, + ) + .to_tuple(), + RequiredField::BillingCountries(vec!["NL"]).to_tuple(), + ]), + common: HashMap::new(), + }, + ), + ( + Connector::Stripe, + RequiredFieldFinal { + mandate: HashMap::from([ + RequiredField::BillingFirstName( + "billing_name", + FieldType::UserFullName, + ) + .to_tuple(), + RequiredField::BillingLastName("billing_name", FieldType::UserFullName) + .to_tuple(), + RequiredField::BillingEmail.to_tuple(), + ]), + non_mandate: HashMap::new(), + common: HashMap::new(), + }, + ), + ( + Connector::Trustpay, + RequiredFieldFinal { + mandate: HashMap::new(), + non_mandate: HashMap::from([ + RequiredField::BillingFirstName( + "billing_first_name", + FieldType::UserBillingName, + ) + .to_tuple(), + RequiredField::BillingAddressLine1.to_tuple(), + RequiredField::BillingAddressCity.to_tuple(), + RequiredField::BillingAddressZip.to_tuple(), + RequiredField::BillingAddressCountries(vec!["NL"]).to_tuple(), + ]), + common: HashMap::new(), + }, + ), + ]), + ), + ( + enums::PaymentMethodType::Sofort, + connectors(vec![ + ( + Connector::Aci, + fields( + vec![], + vec![RequiredField::BillingCountries(vec![ + "ES", "GB", "SE", "AT", "NL", "DE", "CH", "BE", "FR", "FI", "IT", "PL", + ])], + vec![], + ), + ), + (Connector::Adyen, fields(vec![], vec![], vec![])), + ( + Connector::Globalpay, + fields( + vec![], + vec![], + vec![RequiredField::BillingAddressCountries(vec![ + "AT", "BE", "DE", "ES", "IT", "NL", + ])], + ), + ), + (Connector::Mollie, fields(vec![], vec![], vec![])), + (Connector::Nexinets, fields(vec![], vec![], vec![])), + ( + Connector::Nuvei, + RequiredFieldFinal { + mandate: HashMap::new(), + non_mandate: HashMap::from([ + RequiredField::Email.to_tuple(), + RequiredField::BillingFirstName( + "billing_first_name", + FieldType::UserBillingName, + ) + .to_tuple(), + RequiredField::BillingLastName( + "billing_last_name", + FieldType::UserBillingName, + ) + .to_tuple(), + RequiredField::BillingAddressCountries(vec![ + "ES", "GB", "IT", "DE", "FR", "AT", "BE", "NL", "BE", "SK", + ]) + .to_tuple(), + ]), + common: HashMap::new(), + }, + ), + ( + Connector::Paypal, + RequiredFieldFinal { + mandate: HashMap::new(), + non_mandate: HashMap::from([ + RequiredField::BillingCountries(vec![ + "ES", "GB", "AT", "NL", "DE", "BE", + ]) + .to_tuple(), + RequiredField::BillingFirstName( + "billing_name", + FieldType::UserBillingName, + ) + .to_tuple(), + RequiredField::BillingLastName( + "billing_name", + FieldType::UserBillingName, + ) + .to_tuple(), + ]), + common: HashMap::new(), + }, + ), + (Connector::Shift4, fields(vec![], vec![], vec![])), + ( + Connector::Stripe, + RequiredFieldFinal { + mandate: HashMap::from([RequiredField::BillingEmail.to_tuple()]), + non_mandate: HashMap::new(), + common: HashMap::from([ + RequiredField::BillingCountries(vec!["ES", "AT", "NL", "DE", "BE"]) + .to_tuple(), + RequiredField::BillingFirstName( + "account_holder_name", + FieldType::UserBillingName, + ) + .to_tuple(), + RequiredField::BillingLastName( + "account_holder_name", + FieldType::UserBillingName, + ) + .to_tuple(), + ]), + }, + ), + ( + Connector::Trustpay, + RequiredFieldFinal { + mandate: HashMap::new(), + non_mandate: HashMap::from([ + RequiredField::BillingFirstName( + "billing_first_name", + FieldType::UserBillingName, + ) + .to_tuple(), + RequiredField::BillingAddressLine1.to_tuple(), + RequiredField::BillingAddressCity.to_tuple(), + RequiredField::BillingAddressZip.to_tuple(), + RequiredField::BillingAddressCountries(vec![ + "ES", "GB", "SE", "AT", "NL", "DE", "CH", "BE", "FR", "FI", "IT", + "PL", + ]) + .to_tuple(), + ]), + common: HashMap::new(), + }, + ), + ]), + ), + ( + enums::PaymentMethodType::Eps, + connectors(vec![ + ( + Connector::Adyen, + fields(vec![], vec![], vec![RequiredField::EpsBankName]), + ), + ( + Connector::Stripe, + fields( + vec![], + vec![ + RequiredField::BillingFirstName( + "billing_name", + FieldType::UserFullName, + ), + RequiredField::BillingLastName("billing_name", FieldType::UserFullName), + ], + vec![], + ), + ), + ( + Connector::Aci, + fields( + vec![], + vec![RequiredField::BillingCountries(vec!["AT"])], + vec![], + ), + ), + ( + Connector::Globalpay, + fields( + vec![], + vec![], + vec![RequiredField::BillingAddressCountries(vec!["AT"])], + ), + ), + (Connector::Mollie, fields(vec![], vec![], vec![])), + ( + Connector::Paypal, + RequiredFieldFinal { + mandate: HashMap::new(), + non_mandate: HashMap::from([ + RequiredField::BillingFirstName( + "billing_name", + FieldType::UserFullName, + ) + .to_tuple(), + RequiredField::BillingLastName("billing_name", FieldType::UserFullName) + .to_tuple(), + RequiredField::BillingCountries(vec!["AT"]).to_tuple(), + ]), + common: HashMap::new(), + }, + ), + ( + Connector::Trustpay, + RequiredFieldFinal { + mandate: HashMap::new(), + non_mandate: HashMap::from([ + RequiredField::BillingFirstName( + "billing_first_name", + FieldType::UserBillingName, + ) + .to_tuple(), + RequiredField::BillingAddressLine1.to_tuple(), + RequiredField::BillingAddressCity.to_tuple(), + RequiredField::BillingAddressZip.to_tuple(), + RequiredField::BillingAddressCountries(vec!["AT"]).to_tuple(), + ]), + common: HashMap::new(), + }, + ), + (Connector::Shift4, fields(vec![], vec![], vec![])), + ( + Connector::Nuvei, + RequiredFieldFinal { + mandate: HashMap::new(), + non_mandate: HashMap::from([ + RequiredField::Email.to_tuple(), + RequiredField::BillingFirstName( + "billing_first_name", + FieldType::UserBillingName, + ) + .to_tuple(), + RequiredField::BillingLastName( + "billing_last_name", + FieldType::UserBillingName, + ) + .to_tuple(), + RequiredField::BillingAddressCountries(vec!["AT"]).to_tuple(), + ]), + common: HashMap::new(), + }, + ), + ]), + ), + ( + enums::PaymentMethodType::Blik, + connectors(vec![ + ( + Connector::Adyen, + fields(vec![], vec![], vec![RequiredField::BlikCode]), + ), + ( + Connector::Stripe, + fields(vec![], vec![], vec![RequiredField::BlikCode]), + ), + ( + Connector::Trustpay, + RequiredFieldFinal { + mandate: HashMap::new(), + non_mandate: HashMap::new(), + common: HashMap::from([ + RequiredField::Email.to_tuple(), + RequiredField::BillingFirstName( + "billing_first_name", + FieldType::UserBillingName, + ) + .to_tuple(), + RequiredField::BillingLastName( + "billing_last_name", + FieldType::UserBillingName, + ) + .to_tuple(), + RequiredField::BillingAddressLine1.to_tuple(), + RequiredField::BillingAddressCity.to_tuple(), + RequiredField::BillingAddressZip.to_tuple(), + RequiredField::BillingAddressCountries(vec!["ALL"]).to_tuple(), + ]), + }, + ), + ]), + ), + ]) +} + +#[cfg(feature = "v1")] +fn get_wallet_required_fields() -> HashMap { + HashMap::from([ + ( + enums::PaymentMethodType::ApplePay, + connectors(vec![ + (Connector::Stripe, fields(vec![], vec![], vec![])), + (Connector::Adyen, fields(vec![], vec![], vec![])), + ( + Connector::Bankofamerica, + RequiredFieldFinal { + mandate: HashMap::new(), + non_mandate: HashMap::new(), + common: HashMap::from([ + RequiredField::Email.to_tuple(), + RequiredField::BillingFirstName( + "billing_first_name", + FieldType::UserBillingName, + ) + .to_tuple(), + RequiredField::BillingLastName( + "billing_last_name", + FieldType::UserBillingName, + ) + .to_tuple(), + RequiredField::BillingAddressCity.to_tuple(), + RequiredField::BillingAddressState.to_tuple(), + RequiredField::BillingAddressZip.to_tuple(), + RequiredField::BillingAddressCountries(vec!["ALL"]).to_tuple(), + RequiredField::BillingAddressLine1.to_tuple(), + ]), + }, + ), + ( + Connector::Cybersource, + RequiredFieldFinal { + mandate: HashMap::new(), + non_mandate: HashMap::new(), + common: HashMap::from([ + RequiredField::BillingEmail.to_tuple(), + RequiredField::BillingFirstName( + "billing_first_name", + FieldType::UserBillingName, + ) + .to_tuple(), + RequiredField::BillingLastName( + "billing_last_name", + FieldType::UserBillingName, + ) + .to_tuple(), + RequiredField::BillingAddressCity.to_tuple(), + RequiredField::BillingAddressState.to_tuple(), + RequiredField::BillingAddressZip.to_tuple(), + RequiredField::BillingAddressCountries(vec!["ALL"]).to_tuple(), + RequiredField::BillingAddressLine1.to_tuple(), + ]), + }, + ), + ( + Connector::Novalnet, + fields(vec![], vec![], vec![RequiredField::BillingEmail]), + ), + ( + Connector::Wellsfargo, + RequiredFieldFinal { + mandate: HashMap::new(), + non_mandate: HashMap::new(), + common: HashMap::from([ + RequiredField::Email.to_tuple(), + RequiredField::BillingFirstName( + "billing_first_name", + FieldType::UserBillingName, + ) + .to_tuple(), + RequiredField::BillingLastName( + "billing_last_name", + FieldType::UserBillingName, + ) + .to_tuple(), + RequiredField::BillingAddressCity.to_tuple(), + RequiredField::BillingAddressState.to_tuple(), + RequiredField::BillingAddressZip.to_tuple(), + RequiredField::BillingAddressCountries(vec!["ALL"]).to_tuple(), + RequiredField::BillingAddressLine1.to_tuple(), + RequiredField::ShippingFirstName.to_tuple(), + RequiredField::ShippingLastName.to_tuple(), + RequiredField::ShippingAddressCity.to_tuple(), + RequiredField::ShippingAddressState.to_tuple(), + RequiredField::ShippingAddressZip.to_tuple(), + RequiredField::ShippingAddressCountries(vec!["ALL"]).to_tuple(), + RequiredField::ShippingAddressLine1.to_tuple(), + ]), + }, + ), + ]), + ), + ( + enums::PaymentMethodType::SamsungPay, + connectors(vec![( + Connector::Cybersource, + RequiredFieldFinal { + mandate: HashMap::new(), + non_mandate: HashMap::new(), + common: HashMap::from([ + RequiredField::BillingEmail.to_tuple(), + RequiredField::BillingFirstName( + "billing_first_name", + FieldType::UserBillingName, + ) + .to_tuple(), + RequiredField::BillingLastName( + "billing_last_name", + FieldType::UserBillingName, + ) + .to_tuple(), + RequiredField::BillingAddressCity.to_tuple(), + RequiredField::BillingAddressState.to_tuple(), + RequiredField::BillingAddressZip.to_tuple(), + RequiredField::BillingAddressCountries(vec!["ALL"]).to_tuple(), + RequiredField::BillingAddressLine1.to_tuple(), + ]), + }, + )]), + ), + ( + enums::PaymentMethodType::GooglePay, + connectors(vec![ + (Connector::Adyen, fields(vec![], vec![], vec![])), + ( + Connector::Bankofamerica, + RequiredFieldFinal { + mandate: HashMap::new(), + non_mandate: HashMap::new(), + common: HashMap::from([ + RequiredField::Email.to_tuple(), + RequiredField::BillingFirstName( + "billing_first_name", + FieldType::UserBillingName, + ) + .to_tuple(), + RequiredField::BillingLastName( + "billing_last_name", + FieldType::UserBillingName, + ) + .to_tuple(), + RequiredField::BillingAddressCity.to_tuple(), + RequiredField::BillingAddressState.to_tuple(), + RequiredField::BillingAddressZip.to_tuple(), + RequiredField::BillingAddressCountries(vec!["ALL"]).to_tuple(), + RequiredField::BillingAddressLine1.to_tuple(), + ]), + }, + ), + (Connector::Bluesnap, fields(vec![], vec![], vec![])), + (Connector::Noon, fields(vec![], vec![], vec![])), + ( + Connector::Novalnet, + fields(vec![], vec![], vec![RequiredField::BillingEmail]), + ), + (Connector::Nuvei, fields(vec![], vec![], vec![])), + (Connector::Airwallex, fields(vec![], vec![], vec![])), + (Connector::Authorizedotnet, fields(vec![], vec![], vec![])), + (Connector::Checkout, fields(vec![], vec![], vec![])), + (Connector::Globalpay, fields(vec![], vec![], vec![])), + ( + Connector::Multisafepay, + RequiredFieldFinal { + mandate: HashMap::new(), + non_mandate: HashMap::new(), + common: HashMap::from([ + RequiredField::BillingFirstName( + "billing_first_name", + FieldType::UserBillingName, + ) + .to_tuple(), + RequiredField::BillingLastName( + "billing_last_name", + FieldType::UserBillingName, + ) + .to_tuple(), + RequiredField::BillingAddressCity.to_tuple(), + RequiredField::BillingAddressState.to_tuple(), + RequiredField::BillingAddressZip.to_tuple(), + RequiredField::BillingAddressCountries(vec!["ALL"]).to_tuple(), + RequiredField::BillingAddressLine1.to_tuple(), + RequiredField::BillingAddressLine2.to_tuple(), + ]), + }, + ), + ( + Connector::Cybersource, + RequiredFieldFinal { + mandate: HashMap::new(), + non_mandate: HashMap::new(), + common: HashMap::from([ + RequiredField::BillingEmail.to_tuple(), + RequiredField::BillingFirstName( + "billing_first_name", + FieldType::UserBillingName, + ) + .to_tuple(), + RequiredField::BillingLastName( + "billing_last_name", + FieldType::UserBillingName, + ) + .to_tuple(), + RequiredField::BillingAddressCity.to_tuple(), + RequiredField::BillingAddressState.to_tuple(), + RequiredField::BillingAddressZip.to_tuple(), + RequiredField::BillingAddressCountries(vec!["ALL"]).to_tuple(), + RequiredField::BillingAddressLine1.to_tuple(), + ]), + }, + ), + (Connector::Payu, fields(vec![], vec![], vec![])), + (Connector::Rapyd, fields(vec![], vec![], vec![])), + (Connector::Stripe, fields(vec![], vec![], vec![])), + (Connector::Trustpay, fields(vec![], vec![], vec![])), + ( + Connector::Wellsfargo, + RequiredFieldFinal { + mandate: HashMap::new(), + non_mandate: HashMap::new(), + common: HashMap::from([ + RequiredField::Email.to_tuple(), + RequiredField::BillingFirstName( + "billing_first_name", + FieldType::UserBillingName, + ) + .to_tuple(), + RequiredField::BillingLastName( + "billing_last_name", + FieldType::UserBillingName, + ) + .to_tuple(), + RequiredField::BillingAddressCity.to_tuple(), + RequiredField::BillingAddressState.to_tuple(), + RequiredField::BillingAddressZip.to_tuple(), + RequiredField::BillingAddressCountries(vec!["ALL"]).to_tuple(), + RequiredField::BillingAddressLine1.to_tuple(), + RequiredField::ShippingFirstName.to_tuple(), + RequiredField::ShippingLastName.to_tuple(), + RequiredField::ShippingAddressCity.to_tuple(), + RequiredField::ShippingAddressState.to_tuple(), + RequiredField::ShippingAddressZip.to_tuple(), + RequiredField::ShippingAddressCountries(vec!["ALL"]).to_tuple(), + RequiredField::ShippingAddressLine1.to_tuple(), + ]), + }, + ), + ]), + ), + ( + enums::PaymentMethodType::WeChatPay, + connectors(vec![ + (Connector::Stripe, fields(vec![], vec![], vec![])), + (Connector::Adyen, fields(vec![], vec![], vec![])), + ]), + ), + ( + enums::PaymentMethodType::AliPay, + connectors(vec![ + (Connector::Stripe, fields(vec![], vec![], vec![])), + (Connector::Adyen, fields(vec![], vec![], vec![])), + ]), + ), + ( + enums::PaymentMethodType::AliPayHk, + connectors(vec![(Connector::Adyen, fields(vec![], vec![], vec![]))]), + ), + ( + enums::PaymentMethodType::AmazonPay, + connectors(vec![(Connector::Stripe, fields(vec![], vec![], vec![]))]), + ), + ( + enums::PaymentMethodType::Cashapp, + connectors(vec![(Connector::Stripe, fields(vec![], vec![], vec![]))]), + ), + ( + enums::PaymentMethodType::MbWay, + connectors(vec![( + Connector::Adyen, + fields( + vec![], + vec![ + RequiredField::BillingPhone, + RequiredField::BillingPhoneCountryCode, + ], + vec![], + ), + )]), + ), + ( + enums::PaymentMethodType::KakaoPay, + connectors(vec![(Connector::Adyen, fields(vec![], vec![], vec![]))]), + ), + ( + enums::PaymentMethodType::Twint, + connectors(vec![(Connector::Adyen, fields(vec![], vec![], vec![]))]), + ), + ( + enums::PaymentMethodType::Gcash, + connectors(vec![(Connector::Adyen, fields(vec![], vec![], vec![]))]), + ), + ( + enums::PaymentMethodType::Vipps, + connectors(vec![(Connector::Adyen, fields(vec![], vec![], vec![]))]), + ), + ( + enums::PaymentMethodType::Dana, + connectors(vec![(Connector::Adyen, fields(vec![], vec![], vec![]))]), + ), + ( + enums::PaymentMethodType::Momo, + connectors(vec![(Connector::Adyen, fields(vec![], vec![], vec![]))]), + ), + ( + enums::PaymentMethodType::Swish, + connectors(vec![(Connector::Adyen, fields(vec![], vec![], vec![]))]), + ), + ( + enums::PaymentMethodType::TouchNGo, + connectors(vec![(Connector::Adyen, fields(vec![], vec![], vec![]))]), + ), + ( + // Added shipping fields for the SDK flow to accept it from wallet directly, + // this won't show up in SDK in payment's sheet but will be used in the background + enums::PaymentMethodType::Paypal, + connectors(vec![ + ( + Connector::Adyen, + fields(vec![], vec![], vec![RequiredField::BillingEmail]), + ), + (Connector::Braintree, fields(vec![], vec![], vec![])), + ( + Connector::Novalnet, + fields(vec![], vec![], vec![RequiredField::BillingEmail]), + ), + ( + Connector::Paypal, + RequiredFieldFinal { + mandate: HashMap::new(), + non_mandate: HashMap::new(), + common: HashMap::from([ + RequiredField::ShippingFirstName.to_tuple(), + RequiredField::ShippingLastName.to_tuple(), + RequiredField::ShippingAddressCity.to_tuple(), + RequiredField::ShippingAddressState.to_tuple(), + RequiredField::ShippingAddressZip.to_tuple(), + RequiredField::ShippingAddressCountries(vec!["ALL"]).to_tuple(), + RequiredField::ShippingAddressLine1.to_tuple(), + ]), + }, + ), + ]), + ), + ( + enums::PaymentMethodType::Mifinity, + connectors(vec![( + Connector::Mifinity, + fields( + vec![], + vec![], + vec![ + RequiredField::MifinityDateOfBirth, + RequiredField::BillingAddressLine1, + RequiredField::BillingAddressCity, + RequiredField::BillingFirstName("first_name", FieldType::UserFullName), + RequiredField::BillingLastName("last_name", FieldType::UserFullName), + RequiredField::BillingPhone, + RequiredField::BillingPhoneCountryCode, + RequiredField::BillingCountries(vec![ + "BR", "CN", "SG", "MY", "DE", "CH", "DK", "GB", "ES", "AD", "GI", "FI", + "FR", "GR", "HR", "IT", "JP", "MX", "AR", "CO", "CL", "PE", "VE", "UY", + "PY", "BO", "EC", "GT", "HN", "SV", "NI", "CR", "PA", "DO", "CU", "PR", + "NL", "NO", "PL", "PT", "SE", "RU", "TR", "TW", "HK", "MO", "AX", "AL", + "DZ", "AS", "AO", "AI", "AG", "AM", "AW", "AU", "AT", "AZ", "BS", "BH", + "BD", "BB", "BE", "BZ", "BJ", "BM", "BT", "BQ", "BA", "BW", "IO", "BN", + "BG", "BF", "BI", "KH", "CM", "CA", "CV", "KY", "CF", "TD", "CX", "CC", + "KM", "CG", "CK", "CI", "CW", "CY", "CZ", "DJ", "DM", "EG", "GQ", "ER", + "EE", "ET", "FK", "FO", "FJ", "GF", "PF", "TF", "GA", "GM", "GE", "GH", + "GL", "GD", "GP", "GU", "GG", "GN", "GW", "GY", "HT", "HM", "VA", "IS", + "IN", "ID", "IE", "IM", "IL", "JE", "JO", "KZ", "KE", "KI", "KW", "KG", + "LA", "LV", "LB", "LS", "LI", "LT", "LU", "MK", "MG", "MW", "MV", "ML", + "MT", "MH", "MQ", "MR", "MU", "YT", "FM", "MD", "MC", "MN", "ME", "MS", + "MA", "MZ", "NA", "NR", "NP", "NC", "NZ", "NE", "NG", "NU", "NF", "MP", + "OM", "PK", "PW", "PS", "PG", "PH", "PN", "QA", "RE", "RO", "RW", "BL", + "SH", "KN", "LC", "MF", "PM", "VC", "WS", "SM", "ST", "SA", "SN", "RS", + "SC", "SL", "SX", "SK", "SI", "SB", "SO", "ZA", "GS", "KR", "LK", "SR", + "SJ", "SZ", "TH", "TL", "TG", "TK", "TO", "TT", "TN", "TM", "TC", "TV", + "UG", "UA", "AE", "UZ", "VU", "VN", "VG", "VI", "WF", "EH", "ZM", + ]), + RequiredField::BillingEmail, + RequiredField::MifinityLanguagePreference(vec![ + "BR", "PT_BR", "CN", "ZH_CN", "DE", "DK", "DA", "DA_DK", "EN", "ES", + "FI", "FR", "GR", "EL", "EL_GR", "HR", "IT", "JP", "JA", "JA_JP", "LA", + "ES_LA", "NL", "NO", "PL", "PT", "RU", "SV", "SE", "SV_SE", "ZH", "TW", + "ZH_TW", + ]), + ], + ), + )]), + ), + ]) +} + +#[cfg(feature = "v1")] +fn get_pay_later_required_fields() -> HashMap { + HashMap::from([ + ( + enums::PaymentMethodType::AfterpayClearpay, + connectors(vec![ + ( + Connector::Stripe, + fields( + vec![], + vec![ + RequiredField::BillingEmail, + RequiredField::BillingFirstName( + "billing_first_name", + FieldType::UserBillingName, + ), + RequiredField::BillingLastName( + "billing_last_name", + FieldType::UserBillingName, + ), + RequiredField::BillingAddressLine1, + RequiredField::BillingAddressCity, + RequiredField::BillingAddressZip, + RequiredField::BillingAddressCountries(vec![ + "GB", "AU", "CA", "US", "NZ", + ]), + RequiredField::BillingAddressState, + RequiredField::ShippingFirstName, + RequiredField::ShippingLastName, + RequiredField::ShippingAddressCity, + RequiredField::ShippingAddressState, + RequiredField::ShippingAddressZip, + RequiredField::ShippingAddressCountries(vec!["ALL"]), + RequiredField::ShippingAddressLine1, + ], + vec![], + ), + ), + ( + Connector::Adyen, + fields( + vec![], + vec![ + RequiredField::BillingEmail, + RequiredField::BillingFirstName( + "billing_first_name", + FieldType::UserBillingName, + ), + RequiredField::BillingLastName( + "billing_last_name", + FieldType::UserBillingName, + ), + RequiredField::BillingAddressLine1, + RequiredField::BillingAddressLine2, + RequiredField::BillingAddressCity, + RequiredField::BillingAddressZip, + RequiredField::BillingAddressCountries(vec![ + "GB", "AU", "CA", "US", "NZ", + ]), + RequiredField::BillingAddressState, + RequiredField::ShippingAddressCity, + RequiredField::ShippingAddressZip, + RequiredField::ShippingAddressCountries(vec![ + "GB", "AU", "CA", "US", "NZ", + ]), + RequiredField::ShippingAddressLine1, + RequiredField::ShippingAddressLine2, + ], + vec![], + ), + ), + ]), + ), + ( + enums::PaymentMethodType::Klarna, + connectors(vec![ + ( + Connector::Stripe, + fields( + vec![], + vec![ + RequiredField::BillingAddressCountries(vec![ + "AU", "AT", "BE", "CA", "CZ", "DK", "FI", "FR", "GR", "DE", "IE", + "IT", "NL", "NZ", "NO", "PL", "PT", "RO", "ES", "SE", "CH", "GB", + "US", + ]), + RequiredField::BillingEmail, + ], + vec![], + ), + ), + ( + Connector::Adyen, + RequiredFieldFinal { + mandate: HashMap::new(), + non_mandate: HashMap::new(), + common: HashMap::from([ + RequiredField::BillingAddressCountries(vec!["ALL"]).to_tuple(), + RequiredField::BillingEmail.to_tuple(), + ]), + }, + ), + ( + Connector::Klarna, + fields( + vec![], + vec![], + vec![RequiredField::BillingAddressCountries(vec![ + "AU", "AT", "BE", "CA", "CZ", "DK", "FI", "FR", "DE", "GR", "IE", "IT", + "NL", "NZ", "NO", "PL", "PT", "ES", "SE", "CH", "GB", "US", + ])], + ), + ), + ]), + ), + ( + enums::PaymentMethodType::Affirm, + connectors(vec![ + (Connector::Stripe, fields(vec![], vec![], vec![])), + ( + Connector::Adyen, + RequiredFieldFinal { + mandate: HashMap::new(), + non_mandate: HashMap::from([ + RequiredField::BillingUserFirstName.to_tuple(), + RequiredField::BillingUserLastName.to_tuple(), + RequiredField::BillingAddressCity.to_tuple(), + RequiredField::BillingAddressState.to_tuple(), + RequiredField::BillingAddressZip.to_tuple(), + RequiredField::BillingAddressCountries(vec!["US"]).to_tuple(), + RequiredField::BillingPhone.to_tuple(), + RequiredField::BillingPhoneCountryCode.to_tuple(), + RequiredField::BillingEmail.to_tuple(), + RequiredField::BillingAddressLine1.to_tuple(), + RequiredField::BillingAddressLine2.to_tuple(), + RequiredField::ShippingAddressLine1.to_tuple(), + RequiredField::ShippingAddressLine2.to_tuple(), + RequiredField::ShippingAddressZip.to_tuple(), + RequiredField::ShippingAddressCity.to_tuple(), + RequiredField::ShippingCountries(vec!["US"]).to_tuple(), + ]), + common: HashMap::new(), + }, + ), + ]), + ), + ( + enums::PaymentMethodType::PayBright, + connectors(vec![( + Connector::Adyen, + RequiredFieldFinal { + mandate: HashMap::new(), + non_mandate: HashMap::from([ + RequiredField::BillingUserFirstName.to_tuple(), + RequiredField::BillingUserLastName.to_tuple(), + RequiredField::BillingAddressCity.to_tuple(), + RequiredField::BillingAddressState.to_tuple(), + RequiredField::BillingAddressZip.to_tuple(), + RequiredField::BillingAddressCountries(vec!["CA"]).to_tuple(), + RequiredField::BillingPhone.to_tuple(), + RequiredField::BillingPhoneCountryCode.to_tuple(), + RequiredField::BillingEmail.to_tuple(), + RequiredField::BillingAddressLine1.to_tuple(), + RequiredField::BillingAddressLine2.to_tuple(), + RequiredField::ShippingAddressCity.to_tuple(), + RequiredField::ShippingAddressZip.to_tuple(), + RequiredField::ShippingAddressCountries(vec!["ALL"]).to_tuple(), + RequiredField::ShippingAddressLine1.to_tuple(), + RequiredField::ShippingAddressLine2.to_tuple(), + ]), + common: HashMap::new(), + }, + )]), + ), + ( + enums::PaymentMethodType::Walley, + connectors(vec![( + Connector::Adyen, + fields( + vec![], + vec![ + RequiredField::BillingPhone, + RequiredField::BillingAddressCountries(vec!["DK", "FI", "NO", "SE"]), + RequiredField::BillingPhoneCountryCode, + RequiredField::BillingEmail, + ], + vec![], + ), + )]), + ), + ( + enums::PaymentMethodType::Alma, + connectors(vec![( + Connector::Adyen, + RequiredFieldFinal { + mandate: HashMap::new(), + non_mandate: HashMap::from([ + RequiredField::BillingUserFirstName.to_tuple(), + RequiredField::BillingUserLastName.to_tuple(), + RequiredField::BillingAddressCity.to_tuple(), + RequiredField::BillingAddressState.to_tuple(), + RequiredField::BillingAddressZip.to_tuple(), + RequiredField::BillingAddressCountries(vec!["FR"]).to_tuple(), + RequiredField::BillingPhone.to_tuple(), + RequiredField::BillingPhoneCountryCode.to_tuple(), + RequiredField::BillingEmail.to_tuple(), + RequiredField::BillingAddressLine1.to_tuple(), + RequiredField::BillingAddressLine2.to_tuple(), + ]), + common: HashMap::new(), + }, + )]), + ), + ( + enums::PaymentMethodType::Atome, + connectors(vec![( + Connector::Adyen, + RequiredFieldFinal { + mandate: HashMap::new(), + non_mandate: HashMap::from([ + RequiredField::BillingUserFirstName.to_tuple(), + RequiredField::BillingUserLastName.to_tuple(), + RequiredField::BillingAddressCity.to_tuple(), + RequiredField::BillingAddressState.to_tuple(), + RequiredField::BillingAddressZip.to_tuple(), + RequiredField::BillingAddressCountries(vec!["MY", "SG"]).to_tuple(), + RequiredField::BillingPhone.to_tuple(), + RequiredField::BillingPhoneCountryCode.to_tuple(), + RequiredField::BillingEmail.to_tuple(), + RequiredField::BillingAddressLine1.to_tuple(), + RequiredField::BillingAddressLine2.to_tuple(), + ]), + common: HashMap::new(), + }, + )]), + ), + ]) +} + +#[cfg(feature = "v1")] +fn get_voucher_required_fields() -> HashMap { + HashMap::from([ + ( + enums::PaymentMethodType::Boleto, + connectors(vec![ + ( + Connector::Adyen, + RequiredFieldFinal { + mandate: HashMap::new(), + non_mandate: HashMap::from([ + RequiredField::BoletoSocialSecurityNumber.to_tuple(), + RequiredField::BillingUserFirstName.to_tuple(), + RequiredField::BillingUserLastName.to_tuple(), + RequiredField::BillingAddressCity.to_tuple(), + RequiredField::BillingAddressState.to_tuple(), + RequiredField::BillingAddressZip.to_tuple(), + RequiredField::BillingAddressCountries(vec!["BR"]).to_tuple(), + RequiredField::BillingAddressLine1.to_tuple(), + RequiredField::BillingAddressLine2.to_tuple(), + ]), + common: HashMap::new(), + }, + ), + (Connector::Zen, fields(vec![], vec![], vec![])), + ]), + ), + ( + enums::PaymentMethodType::Alfamart, + connectors(vec![( + Connector::Adyen, + fields(vec![], billing_email_name(), vec![]), + )]), + ), + ( + enums::PaymentMethodType::Indomaret, + connectors(vec![( + Connector::Adyen, + fields(vec![], billing_email_name(), vec![]), + )]), + ), + ( + enums::PaymentMethodType::Oxxo, + connectors(vec![(Connector::Adyen, fields(vec![], vec![], vec![]))]), + ), + ( + enums::PaymentMethodType::SevenEleven, + connectors(vec![( + Connector::Adyen, + fields(vec![], billing_email_name_phone(), vec![]), + )]), + ), + ( + enums::PaymentMethodType::Lawson, + connectors(vec![( + Connector::Adyen, + fields(vec![], billing_email_name_phone(), vec![]), + )]), + ), + ( + enums::PaymentMethodType::MiniStop, + connectors(vec![( + Connector::Adyen, + fields(vec![], billing_email_name_phone(), vec![]), + )]), + ), + ( + enums::PaymentMethodType::FamilyMart, + connectors(vec![( + Connector::Adyen, + fields(vec![], billing_email_name_phone(), vec![]), + )]), + ), + ( + enums::PaymentMethodType::Seicomart, + connectors(vec![( + Connector::Adyen, + fields(vec![], billing_email_name_phone(), vec![]), + )]), + ), + ( + enums::PaymentMethodType::PayEasy, + connectors(vec![( + Connector::Adyen, + fields(vec![], billing_email_name_phone(), vec![]), + )]), + ), + ]) +} + +#[cfg(feature = "v1")] +fn get_bank_debit_required_fields() -> HashMap { + HashMap::from([ + ( + enums::PaymentMethodType::Ach, + connectors(vec![ + ( + Connector::Stripe, + RequiredFieldFinal { + mandate: HashMap::new(), + non_mandate: HashMap::new(), + common: HashMap::from([ + RequiredField::BillingFirstName( + "billing_first_name", + FieldType::UserBillingName, + ) + .to_tuple(), + RequiredField::BillingLastName( + "owner_name", + FieldType::UserBillingName, + ) + .to_tuple(), + RequiredField::AchBankDebitAccountNumber.to_tuple(), + RequiredField::AchBankDebitRoutingNumber.to_tuple(), + ]), + }, + ), + ( + Connector::Adyen, + RequiredFieldFinal { + mandate: HashMap::new(), + non_mandate: HashMap::new(), + common: HashMap::from([ + RequiredField::BillingFirstName( + "owner_name", + FieldType::UserBillingName, + ) + .to_tuple(), + RequiredField::BillingLastName( + "owner_name", + FieldType::UserBillingName, + ) + .to_tuple(), + RequiredField::AchBankDebitAccountNumber.to_tuple(), + RequiredField::AchBankDebitRoutingNumber.to_tuple(), + ]), + }, + ), + ]), + ), + ( + enums::PaymentMethodType::Sepa, + connectors(vec![ + ( + Connector::Stripe, + RequiredFieldFinal { + mandate: HashMap::new(), + non_mandate: HashMap::new(), + common: HashMap::from([ + RequiredField::BillingFirstName( + "billing_first_name", + FieldType::UserBillingName, + ) + .to_tuple(), + RequiredField::BillingLastName( + "owner_name", + FieldType::UserBillingName, + ) + .to_tuple(), + RequiredField::SepaBankDebitIban.to_tuple(), + RequiredField::BillingEmail.to_tuple(), + ]), + }, + ), + ( + Connector::Adyen, + RequiredFieldFinal { + mandate: HashMap::new(), + non_mandate: HashMap::new(), + common: HashMap::from([ + RequiredField::BillingFirstName( + "owner_name", + FieldType::UserBillingName, + ) + .to_tuple(), + RequiredField::BillingLastName( + "owner_name", + FieldType::UserBillingName, + ) + .to_tuple(), + RequiredField::SepaBankDebitIban.to_tuple(), + ]), + }, + ), + ( + Connector::Deutschebank, + RequiredFieldFinal { + mandate: HashMap::new(), + non_mandate: HashMap::new(), + common: HashMap::from([ + RequiredField::BillingFirstName( + "owner_name", + FieldType::UserBillingName, + ) + .to_tuple(), + RequiredField::BillingLastName( + "owner_name", + FieldType::UserBillingName, + ) + .to_tuple(), + RequiredField::BillingEmail.to_tuple(), + RequiredField::SepaBankDebitIban.to_tuple(), + ]), + }, + ), + ( + Connector::Inespay, + fields(vec![], vec![], vec![RequiredField::SepaBankDebitIban]), + ), + ]), + ), + ( + enums::PaymentMethodType::Bacs, + connectors(vec![ + ( + Connector::Stripe, + RequiredFieldFinal { + mandate: HashMap::new(), + non_mandate: HashMap::new(), + common: HashMap::from([ + RequiredField::BillingFirstName( + "billing_first_name", + FieldType::UserBillingName, + ) + .to_tuple(), + RequiredField::BacsBankDebitAccountNumber.to_tuple(), + RequiredField::BacsBankDebitSortCode.to_tuple(), + RequiredField::BillingAddressCountries(vec!["UK"]).to_tuple(), + RequiredField::BillingAddressZip.to_tuple(), + RequiredField::BillingAddressLine1.to_tuple(), + ]), + }, + ), + ( + Connector::Adyen, + RequiredFieldFinal { + mandate: HashMap::new(), + non_mandate: HashMap::new(), + common: HashMap::from([ + RequiredField::BillingFirstName( + "owner_name", + FieldType::UserBillingName, + ) + .to_tuple(), + RequiredField::BillingLastName( + "owner_name", + FieldType::UserBillingName, + ) + .to_tuple(), + RequiredField::BacsBankDebitAccountNumber.to_tuple(), + RequiredField::BacsBankDebitSortCode.to_tuple(), + ]), + }, + ), + ]), + ), + ( + enums::PaymentMethodType::Becs, + connectors(vec![ + ( + Connector::Stripe, + RequiredFieldFinal { + mandate: HashMap::new(), + non_mandate: HashMap::new(), + common: HashMap::from([ + RequiredField::BillingFirstName( + "billing_first_name", + FieldType::UserBillingName, + ) + .to_tuple(), + RequiredField::BillingLastName( + "owner_name", + FieldType::UserBillingName, + ) + .to_tuple(), + RequiredField::BecsBankDebitAccountNumber.to_tuple(), + RequiredField::BecsBankDebitBsbNumber.to_tuple(), + RequiredField::BillingEmail.to_tuple(), + ]), + }, + ), + ( + Connector::Adyen, + RequiredFieldFinal { + mandate: HashMap::new(), + non_mandate: HashMap::new(), + common: HashMap::from([ + RequiredField::BillingFirstName( + "owner_name", + FieldType::UserBillingName, + ) + .to_tuple(), + RequiredField::BillingLastName( + "owner_name", + FieldType::UserBillingName, + ) + .to_tuple(), + RequiredField::BecsBankDebitAccountNumber.to_tuple(), + RequiredField::BecsBankDebitSortCode.to_tuple(), + ]), + }, + ), + ]), + ), + ]) +} + +#[cfg(feature = "v1")] +fn get_bank_transfer_required_fields() -> HashMap { + HashMap::from([ + ( + enums::PaymentMethodType::Multibanco, + connectors(vec![( + Connector::Stripe, + fields(vec![], vec![RequiredField::BillingEmail], vec![]), + )]), + ), + ( + enums::PaymentMethodType::LocalBankTransfer, + connectors(vec![( + Connector::Zsl, + fields( + vec![], + vec![ + RequiredField::BillingAddressCountries(vec!["CN"]), + RequiredField::BillingAddressCity, + ], + vec![], + ), + )]), + ), + ( + enums::PaymentMethodType::Ach, + connectors(vec![( + Connector::Stripe, + fields(vec![], vec![], vec![RequiredField::BillingEmail]), + )]), + ), + ( + enums::PaymentMethodType::Pix, + connectors(vec![ + ( + Connector::Itaubank, + RequiredFieldFinal { + mandate: HashMap::new(), + non_mandate: HashMap::new(), + common: HashMap::from([ + RequiredField::PixKey.to_tuple(), + RequiredField::PixCnpj.to_tuple(), + RequiredField::PixCpf.to_tuple(), + RequiredField::BillingUserFirstName.to_tuple(), + RequiredField::BillingUserLastName.to_tuple(), + ]), + }, + ), + (Connector::Adyen, fields(vec![], vec![], vec![])), + ]), + ), + ( + enums::PaymentMethodType::PermataBankTransfer, + connectors(vec![( + Connector::Adyen, + fields(vec![], billing_email_name(), vec![]), + )]), + ), + ( + enums::PaymentMethodType::BcaBankTransfer, + connectors(vec![( + Connector::Adyen, + fields(vec![], billing_email_name(), vec![]), + )]), + ), + ( + enums::PaymentMethodType::BniVa, + connectors(vec![( + Connector::Adyen, + fields(vec![], billing_email_name(), vec![]), + )]), + ), + ( + enums::PaymentMethodType::BriVa, + connectors(vec![( + Connector::Adyen, + fields(vec![], billing_email_name(), vec![]), + )]), + ), + ( + enums::PaymentMethodType::CimbVa, + connectors(vec![( + Connector::Adyen, + fields(vec![], billing_email_name(), vec![]), + )]), + ), + ( + enums::PaymentMethodType::DanamonVa, + connectors(vec![( + Connector::Adyen, + fields(vec![], billing_email_name(), vec![]), + )]), + ), + ( + enums::PaymentMethodType::MandiriVa, + connectors(vec![( + Connector::Adyen, + fields(vec![], billing_email_name(), vec![]), + )]), + ), + ( + enums::PaymentMethodType::SepaBankTransfer, + connectors(vec![ + ( + Connector::Stripe, + fields( + vec![], + vec![], + vec![ + RequiredField::BillingEmail, + RequiredField::BillingUserFirstName, + RequiredField::BillingUserLastName, + RequiredField::BillingAddressCountries(vec![ + "BE", "DE", "ES", "FR", "IE", "NL", + ]), + ], + ), + ), + ( + Connector::Trustpay, + fields( + vec![], + vec![], + vec![ + RequiredField::Email, + RequiredField::BillingFirstName( + "billing_first_name", + FieldType::UserBillingName, + ), + RequiredField::BillingLastName( + "billing_last_name", + FieldType::UserBillingName, + ), + RequiredField::BillingAddressLine1, + RequiredField::BillingAddressCity, + RequiredField::BillingAddressZip, + RequiredField::BillingAddressCountries(vec!["ALL"]), + ], + ), + ), + ]), + ), + ( + enums::PaymentMethodType::InstantBankTransfer, + connectors(vec![( + Connector::Trustpay, + fields( + vec![], + vec![], + vec![ + RequiredField::Email, + RequiredField::BillingFirstName( + "billing_first_name", + FieldType::UserBillingName, + ), + RequiredField::BillingLastName( + "billing_last_name", + FieldType::UserBillingName, + ), + RequiredField::BillingAddressLine1, + RequiredField::BillingAddressCity, + RequiredField::BillingAddressZip, + RequiredField::BillingAddressCountries(vec!["ALL"]), + ], + ), + )]), + ), + ( + enums::PaymentMethodType::Bacs, + connectors(vec![( + Connector::Stripe, + fields(vec![], vec![], billing_email_name()), + )]), + ), + ]) +} + +#[test] +fn test_required_fields_to_json() { + #![allow(clippy::unwrap_used)] + + // Test billing fields + let billing_fields = get_billing_required_fields(); + // let billing_json = serde_json::to_string_pretty(&billing_fields)?; + + // Verify billing fields have expected entries + assert!(billing_fields.contains_key("billing.address.first_name")); + assert!(billing_fields.contains_key("billing.address.last_name")); + assert!(billing_fields.contains_key("billing.address.city")); + assert!(billing_fields.contains_key("billing.address.zip")); + assert!(billing_fields.contains_key("billing.email")); + + // Verify specific billing field properties + let billing_first_name = billing_fields.get("billing.address.first_name").unwrap(); + assert_eq!(billing_first_name.display_name, "billing_first_name"); + assert!(matches!( + billing_first_name.field_type, + FieldType::UserBillingName + )); + + // Test shipping fields + let shipping_fields = get_shipping_required_fields(); + // let shipping_json = serde_json::to_string_pretty(&shipping_fields)?; + + // Verify shipping fields have expected entries + assert!(shipping_fields.contains_key("shipping.address.first_name")); + assert!(shipping_fields.contains_key("shipping.address.last_name")); + assert!(shipping_fields.contains_key("shipping.address.city")); + assert!(shipping_fields.contains_key("shipping.address.zip")); + assert!(shipping_fields.contains_key("shipping.email")); + + // Verify specific shipping field properties + let shipping_address_line1 = shipping_fields.get("shipping.address.line1").unwrap(); + assert_eq!(shipping_address_line1.display_name, "line1"); + assert!(matches!( + shipping_address_line1.field_type, + FieldType::UserShippingAddressLine1 + )); + + #[cfg(feature = "v1")] + { + let default_fields = RequiredFields::default(); + // let default_json = serde_json::to_string_pretty(&default_fields.0)?; + + // Check default fields for payment methods + assert!(default_fields.0.contains_key(&enums::PaymentMethod::Card)); + assert!(default_fields.0.contains_key(&enums::PaymentMethod::Wallet)); + + // Verify card payment method types + if let Some(card_method) = default_fields.0.get(&enums::PaymentMethod::Card) { + assert!(card_method + .0 + .contains_key(&enums::PaymentMethodType::Credit)); + assert!(card_method.0.contains_key(&enums::PaymentMethodType::Debit)); + } + + // Verify specific connector fields + if let Some(card_method) = default_fields.0.get(&enums::PaymentMethod::Card) { + if let Some(credit_type) = card_method.0.get(&enums::PaymentMethodType::Credit) { + // Check if Stripe connector exists + assert!(credit_type.fields.contains_key(&Connector::Stripe)); + + // Verify Stripe required fields + if let Some(stripe_fields) = credit_type.fields.get(&Connector::Stripe) { + // Check that card_basic fields are in "common" fields for Stripe + assert!(stripe_fields + .common + .contains_key("payment_method_data.card.card_number")); + assert!(stripe_fields + .common + .contains_key("payment_method_data.card.card_exp_month")); + assert!(stripe_fields + .common + .contains_key("payment_method_data.card.card_exp_year")); + assert!(stripe_fields + .common + .contains_key("payment_method_data.card.card_cvc")); + } + } + } + // print the result of default required fields as json in new file + serde_json::to_writer_pretty( + std::fs::File::create("default_required_fields.json").unwrap(), + &default_fields, + ) + .unwrap(); + } +} diff --git a/crates/payment_methods/src/configs/settings.rs b/crates/payment_methods/src/configs/settings.rs new file mode 100644 index 0000000000..888a17cd0a --- /dev/null +++ b/crates/payment_methods/src/configs/settings.rs @@ -0,0 +1,144 @@ +use std::collections::{HashMap, HashSet}; + +use api_models::{enums, payment_methods::RequiredFieldInfo}; +use common_utils::errors::CustomResult; +use hyperswitch_interfaces::secrets_interface::{ + secret_handler::SecretsHandler, + secret_state::{RawSecret, SecretStateContainer, SecuredSecret}, + SecretManagementInterface, SecretsManagementError, +}; +use masking::Secret; +use serde::{self, Deserialize, Serialize}; + +#[derive(Debug, Serialize, Deserialize, Clone)] +#[cfg_attr(feature = "v2", derive(Default))] // Configs are read from the config file in config/payment_required_fields.toml +pub struct RequiredFields(pub HashMap); + +#[derive(Debug, Serialize, Deserialize, Clone)] +pub struct PaymentMethodType(pub HashMap); + +#[derive(Debug, Serialize, Deserialize, Clone)] +pub struct ConnectorFields { + pub fields: HashMap, +} + +#[cfg(feature = "v1")] +#[derive(Debug, Serialize, Deserialize, Clone)] +pub struct RequiredFieldFinal { + pub mandate: HashMap, + pub non_mandate: HashMap, + pub common: HashMap, +} +#[cfg(feature = "v2")] +#[derive(Debug, Serialize, Deserialize, Clone)] +pub struct RequiredFieldFinal { + pub mandate: Option>, + pub non_mandate: Option>, + pub common: Option>, +} + +#[derive(Debug, Deserialize, Clone, Default)] +pub struct PaymentMethodAuth { + pub redis_expiry: i64, + pub pm_auth_key: Secret, +} + +#[async_trait::async_trait] +impl SecretsHandler for PaymentMethodAuth { + async fn convert_to_raw_secret( + value: SecretStateContainer, + secret_management_client: &dyn SecretManagementInterface, + ) -> CustomResult, SecretsManagementError> { + let payment_method_auth = value.get_inner(); + + let pm_auth_key = secret_management_client + .get_secret(payment_method_auth.pm_auth_key.clone()) + .await?; + + Ok(value.transition_state(|payment_method_auth| Self { + pm_auth_key, + ..payment_method_auth + })) + } +} + +#[derive(Debug, Deserialize, Clone, Default)] +#[serde(default)] +pub struct EligiblePaymentMethods { + #[serde(deserialize_with = "deserialize_hashset")] + pub sdk_eligible_payment_methods: HashSet, +} +#[derive(Debug, Deserialize, Clone)] +pub struct SupportedPaymentMethodsForMandate( + pub HashMap, +); + +#[derive(Debug, Deserialize, Clone)] +pub struct SupportedPaymentMethodTypesForMandate( + pub HashMap, +); + +#[derive(Debug, Deserialize, Clone)] +pub struct SupportedConnectorsForMandate { + #[serde(deserialize_with = "deserialize_hashset")] + pub connector_list: HashSet, +} +#[derive(Debug, Deserialize, Clone)] +pub struct Mandates { + pub supported_payment_methods: SupportedPaymentMethodsForMandate, + pub update_mandate_supported: SupportedPaymentMethodsForMandate, +} + +#[derive(Debug, Deserialize, Clone)] +pub struct ZeroMandates { + pub supported_payment_methods: SupportedPaymentMethodsForMandate, +} + +fn deserialize_hashset_inner(value: impl AsRef) -> Result, String> +where + T: Eq + std::str::FromStr + std::hash::Hash, + ::Err: std::fmt::Display, +{ + let (values, errors) = value + .as_ref() + .trim() + .split(',') + .map(|s| { + T::from_str(s.trim()).map_err(|error| { + format!( + "Unable to deserialize `{}` as `{}`: {error}", + s.trim(), + std::any::type_name::() + ) + }) + }) + .fold( + (HashSet::new(), Vec::new()), + |(mut values, mut errors), result| match result { + Ok(t) => { + values.insert(t); + (values, errors) + } + Err(error) => { + errors.push(error); + (values, errors) + } + }, + ); + if !errors.is_empty() { + Err(format!("Some errors occurred:\n{}", errors.join("\n"))) + } else { + Ok(values) + } +} + +fn deserialize_hashset<'a, D, T>(deserializer: D) -> Result, D::Error> +where + D: serde::Deserializer<'a>, + T: Eq + std::str::FromStr + std::hash::Hash, + ::Err: std::fmt::Display, +{ + use serde::de::Error; + + deserialize_hashset_inner(::deserialize(deserializer)?).map_err(D::Error::custom) +} diff --git a/crates/payment_methods/src/lib.rs b/crates/payment_methods/src/lib.rs index 266c62acc7..015992da4a 100644 --- a/crates/payment_methods/src/lib.rs +++ b/crates/payment_methods/src/lib.rs @@ -1 +1,2 @@ +pub mod configs; pub mod state; diff --git a/crates/router/Cargo.toml b/crates/router/Cargo.toml index 0eae31ace8..31f5d23795 100644 --- a/crates/router/Cargo.toml +++ b/crates/router/Cargo.toml @@ -26,15 +26,15 @@ oltp = ["storage_impl/oltp"] kv_store = ["scheduler/kv_store"] accounts_cache = [] vergen = ["router_env/vergen"] -dummy_connector = ["api_models/dummy_connector", "euclid/dummy_connector", "hyperswitch_interfaces/dummy_connector", "kgraph_utils/dummy_connector", "hyperswitch_domain_models/dummy_connector"] +dummy_connector = ["api_models/dummy_connector", "euclid/dummy_connector", "hyperswitch_interfaces/dummy_connector", "kgraph_utils/dummy_connector", "payment_methods/dummy_connector", "hyperswitch_domain_models/dummy_connector"] external_access_dc = ["dummy_connector"] detailed_errors = ["api_models/detailed_errors", "error-stack/serde"] payouts = ["api_models/payouts", "common_enums/payouts", "hyperswitch_connectors/payouts", "hyperswitch_domain_models/payouts", "storage_impl/payouts"] payout_retry = ["payouts"] recon = ["email", "api_models/recon"] retry = [] -v2 = ["customer_v2", "payment_methods_v2", "common_default", "api_models/v2", "diesel_models/v2", "hyperswitch_domain_models/v2", "storage_impl/v2", "kgraph_utils/v2", "common_utils/v2", "hyperswitch_connectors/v2","hyperswitch_interfaces/v2", "common_types/v2","revenue_recovery","refunds_v2","scheduler/v2","euclid/v2"] -v1 = ["common_default", "api_models/v1", "diesel_models/v1", "hyperswitch_domain_models/v1", "storage_impl/v1", "hyperswitch_interfaces/v1", "kgraph_utils/v1", "common_utils/v1", "hyperswitch_connectors/v1", "common_types/v1","scheduler/v1"] +v2 = ["customer_v2", "payment_methods_v2", "common_default", "api_models/v2", "diesel_models/v2", "hyperswitch_domain_models/v2", "storage_impl/v2", "kgraph_utils/v2", "common_utils/v2", "hyperswitch_connectors/v2","hyperswitch_interfaces/v2", "common_types/v2","revenue_recovery","scheduler/v2", "refunds_v2", "euclid/v2", "payment_methods/v2"] +v1 = ["common_default", "api_models/v1", "diesel_models/v1", "hyperswitch_domain_models/v1", "storage_impl/v1", "hyperswitch_interfaces/v1", "kgraph_utils/v1", "common_utils/v1", "hyperswitch_connectors/v1", "common_types/v1","scheduler/v1", "payment_methods/v1"] customer_v2 = ["api_models/customer_v2", "diesel_models/customer_v2", "hyperswitch_domain_models/customer_v2", "storage_impl/customer_v2"] payment_methods_v2 = ["api_models/payment_methods_v2", "diesel_models/payment_methods_v2", "hyperswitch_domain_models/payment_methods_v2", "storage_impl/payment_methods_v2", "common_utils/payment_methods_v2"] dynamic_routing = ["external_services/dynamic_routing", "storage_impl/dynamic_routing", "api_models/dynamic_routing"] diff --git a/crates/router/src/configs/defaults.rs b/crates/router/src/configs/defaults.rs index 8912d551f9..ac3a446b01 100644 --- a/crates/router/src/configs/defaults.rs +++ b/crates/router/src/configs/defaults.rs @@ -1,13 +1,10 @@ -use std::collections::{HashMap, HashSet}; +use std::collections::HashSet; -use api_models::{enums, payment_methods::RequiredFieldInfo}; use common_utils::id_type; #[cfg(feature = "payouts")] pub mod payout_required_fields; -pub mod payment_connector_required_fields; - impl Default for super::settings::Server { fn default() -> Self { Self { @@ -174,206 +171,3 @@ impl Default for super::settings::ApiKeys { } } } - -pub fn get_billing_required_fields() -> HashMap { - HashMap::from([ - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "billing_first_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - }, - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "billing_last_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - }, - ), - ( - "billing.address.city".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.city".to_string(), - display_name: "city".to_string(), - field_type: enums::FieldType::UserAddressCity, - value: None, - }, - ), - ( - "billing.address.state".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.state".to_string(), - display_name: "state".to_string(), - field_type: enums::FieldType::UserAddressState, - value: None, - }, - ), - ( - "billing.address.zip".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.zip".to_string(), - display_name: "zip".to_string(), - field_type: enums::FieldType::UserAddressPincode, - value: None, - }, - ), - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserAddressCountry { - options: vec!["ALL".to_string()], - }, - value: None, - }, - ), - ( - "billing.address.line1".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.line1".to_string(), - display_name: "line1".to_string(), - field_type: enums::FieldType::UserAddressLine1, - value: None, - }, - ), - ( - "billing.address.line2".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.line2".to_string(), - display_name: "line2".to_string(), - field_type: enums::FieldType::UserAddressLine2, - value: None, - }, - ), - ( - "billing.phone.number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.phone.number".to_string(), - display_name: "phone_number".to_string(), - field_type: enums::FieldType::UserPhoneNumber, - value: None, - }, - ), - ( - "billing.phone.country_code".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.phone.country_code".to_string(), - display_name: "dialing_code".to_string(), - field_type: enums::FieldType::UserPhoneNumberCountryCode, - value: None, - }, - ), - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - }, - ), - ]) -} - -pub fn get_shipping_required_fields() -> HashMap { - HashMap::from([ - ( - "shipping.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "shipping.address.first_name".to_string(), - display_name: "shipping_first_name".to_string(), - field_type: enums::FieldType::UserShippingName, - value: None, - }, - ), - ( - "shipping.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "shipping.address.last_name".to_string(), - display_name: "shipping_last_name".to_string(), - field_type: enums::FieldType::UserShippingName, - value: None, - }, - ), - ( - "shipping.address.city".to_string(), - RequiredFieldInfo { - required_field: "shipping.address.city".to_string(), - display_name: "city".to_string(), - field_type: enums::FieldType::UserShippingAddressCity, - value: None, - }, - ), - ( - "shipping.address.state".to_string(), - RequiredFieldInfo { - required_field: "shipping.address.state".to_string(), - display_name: "state".to_string(), - field_type: enums::FieldType::UserShippingAddressState, - value: None, - }, - ), - ( - "shipping.address.zip".to_string(), - RequiredFieldInfo { - required_field: "shipping.address.zip".to_string(), - display_name: "zip".to_string(), - field_type: enums::FieldType::UserShippingAddressPincode, - value: None, - }, - ), - ( - "shipping.address.country".to_string(), - RequiredFieldInfo { - required_field: "shipping.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserShippingAddressCountry { - options: vec!["ALL".to_string()], - }, - value: None, - }, - ), - ( - "shipping.address.line1".to_string(), - RequiredFieldInfo { - required_field: "shipping.address.line1".to_string(), - display_name: "line1".to_string(), - field_type: enums::FieldType::UserShippingAddressLine1, - value: None, - }, - ), - ( - "shipping.phone.number".to_string(), - RequiredFieldInfo { - required_field: "shipping.phone.number".to_string(), - display_name: "phone_number".to_string(), - field_type: enums::FieldType::UserPhoneNumber, - value: None, - }, - ), - ( - "shipping.phone.country_code".to_string(), - RequiredFieldInfo { - required_field: "shipping.phone.country_code".to_string(), - display_name: "dialing_code".to_string(), - field_type: enums::FieldType::UserPhoneNumberCountryCode, - value: None, - }, - ), - ( - "shipping.email".to_string(), - RequiredFieldInfo { - required_field: "shipping.email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - }, - ), - ]) -} diff --git a/crates/router/src/configs/defaults/payment_connector_required_fields.rs b/crates/router/src/configs/defaults/payment_connector_required_fields.rs deleted file mode 100644 index acf2b60f0c..0000000000 --- a/crates/router/src/configs/defaults/payment_connector_required_fields.rs +++ /dev/null @@ -1,14211 +0,0 @@ -use std::collections::{HashMap, HashSet}; - -use api_models::{enums, payment_methods::RequiredFieldInfo}; - -use crate::settings::{ - self, ConnectorFields, Mandates, PaymentMethodType, RequiredFieldFinal, - SupportedConnectorsForMandate, SupportedPaymentMethodTypesForMandate, - SupportedPaymentMethodsForMandate, ZeroMandates, -}; - -impl Default for ZeroMandates { - fn default() -> Self { - Self { - supported_payment_methods: SupportedPaymentMethodsForMandate(HashMap::new()), - } - } -} - -impl Default for Mandates { - fn default() -> Self { - Self { - supported_payment_methods: SupportedPaymentMethodsForMandate(HashMap::from([ - ( - enums::PaymentMethod::PayLater, - SupportedPaymentMethodTypesForMandate(HashMap::from([( - enums::PaymentMethodType::Klarna, - SupportedConnectorsForMandate { - connector_list: HashSet::from([enums::Connector::Adyen]), - }, - )])), - ), - ( - enums::PaymentMethod::Wallet, - SupportedPaymentMethodTypesForMandate(HashMap::from([ - ( - enums::PaymentMethodType::GooglePay, - SupportedConnectorsForMandate { - connector_list: HashSet::from([ - enums::Connector::Stripe, - enums::Connector::Adyen, - enums::Connector::Globalpay, - enums::Connector::Multisafepay, - enums::Connector::Bankofamerica, - enums::Connector::Novalnet, - enums::Connector::Noon, - enums::Connector::Cybersource, - enums::Connector::Wellsfargo, - ]), - }, - ), - ( - enums::PaymentMethodType::ApplePay, - SupportedConnectorsForMandate { - connector_list: HashSet::from([ - enums::Connector::Stripe, - enums::Connector::Adyen, - enums::Connector::Bankofamerica, - enums::Connector::Cybersource, - enums::Connector::Novalnet, - enums::Connector::Wellsfargo, - ]), - }, - ), - ( - enums::PaymentMethodType::SamsungPay, - SupportedConnectorsForMandate { - connector_list: HashSet::from([enums::Connector::Cybersource]), - }, - ), - ])), - ), - ( - enums::PaymentMethod::Card, - SupportedPaymentMethodTypesForMandate(HashMap::from([ - ( - enums::PaymentMethodType::Credit, - SupportedConnectorsForMandate { - connector_list: HashSet::from([ - enums::Connector::Aci, - enums::Connector::Adyen, - enums::Connector::Authorizedotnet, - enums::Connector::Globalpay, - enums::Connector::Worldpay, - enums::Connector::Fiuu, - enums::Connector::Multisafepay, - enums::Connector::Nexinets, - enums::Connector::Noon, - enums::Connector::Novalnet, - enums::Connector::Payme, - enums::Connector::Stripe, - enums::Connector::Bankofamerica, - enums::Connector::Cybersource, - enums::Connector::Wellsfargo, - ]), - }, - ), - ( - enums::PaymentMethodType::Debit, - SupportedConnectorsForMandate { - connector_list: HashSet::from([ - enums::Connector::Aci, - enums::Connector::Adyen, - enums::Connector::Authorizedotnet, - enums::Connector::Globalpay, - enums::Connector::Worldpay, - enums::Connector::Fiuu, - enums::Connector::Multisafepay, - enums::Connector::Nexinets, - enums::Connector::Noon, - enums::Connector::Novalnet, - enums::Connector::Payme, - enums::Connector::Stripe, - ]), - }, - ), - ])), - ), - ])), - update_mandate_supported: SupportedPaymentMethodsForMandate(HashMap::default()), - } - } -} - -#[cfg(feature = "v1")] -impl Default for settings::RequiredFields { - fn default() -> Self { - Self(HashMap::from([ - ( - enums::PaymentMethod::Card, - PaymentMethodType(HashMap::from([ - ( - enums::PaymentMethodType::Debit, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Aci, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ] - ), - } - ), - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ] - ), - } - ), - ( - enums::Connector::Airwallex, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ) - ] - ), - common: HashMap::new(), - } - ), - ( - enums::Connector::Authorizedotnet, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ) - ] - ), - } - ), - ( - enums::Connector::Bambora, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ) - ] - ), - common: HashMap::new(), - } - ), - ( - enums::Connector::Bankofamerica, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ), - ( - "email".to_string(), - RequiredFieldInfo { - required_field: "email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.city".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.city".to_string(), - display_name: "city".to_string(), - field_type: enums::FieldType::UserAddressCity, - value: None, - } - ), - ( - "billing.address.state".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.state".to_string(), - display_name: "state".to_string(), - field_type: enums::FieldType::UserAddressState, - value: None, - } - ), - ( - "billing.address.zip".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.zip".to_string(), - display_name: "zip".to_string(), - field_type: enums::FieldType::UserAddressPincode, - value: None, - } - ), - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserAddressCountry{ - options: vec![ - "ALL".to_string(), - ] - }, - value: None, - } - ), - ( - "billing.address.line1".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.line1".to_string(), - display_name: "line1".to_string(), - field_type: enums::FieldType::UserAddressLine1, - value: None, - } - ), - ] - ), - } - ), - ( - enums::Connector::Billwerk, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ) - ] - ), - } - ), - ( - enums::Connector::Bluesnap, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ), - ( - "email".to_string(), - RequiredFieldInfo { - required_field: "email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ) - ] - ), - common: HashMap::new(), - } - ), - ( - enums::Connector::Boku, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ) - ] - ), - } - ), - ( - enums::Connector::Braintree, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ) - ] - ), - } - ), - ( - enums::Connector::Checkout, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ) - ] - ), - common: HashMap::new(), - } - ), - ( - enums::Connector::Coinbase, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from( - [ - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ) - ] - ), - common: HashMap::new(), - } - ), - ( - enums::Connector::Cybersource, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common:HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "billing.address.line1".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.line1".to_string(), - display_name: "line1".to_string(), - field_type: enums::FieldType::UserAddressLine1, - value: None, - } - ), - ( - "billing.address.city".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.city".to_string(), - display_name: "city".to_string(), - field_type: enums::FieldType::UserAddressCity, - value: None, - } - ), - ( - "billing.address.state".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.state".to_string(), - display_name: "state".to_string(), - field_type: enums::FieldType::UserAddressState, - value: None, - } - ), - ( - "billing.address.zip".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.zip".to_string(), - display_name: "zip".to_string(), - field_type: enums::FieldType::UserAddressPincode, - value: None, - } - ), - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserAddressCountry{ - options: vec![ - "ALL".to_string(), - ] - }, - value: None, - } - ) - ] - ), - } - ), - ( - enums::Connector::Datatrans, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ] - ), - } - ), - ( - enums::Connector::Deutschebank, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate : HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ), - ( - "email".to_string(), - RequiredFieldInfo { - required_field: "email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "billing.address.line1".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.line1".to_string(), - display_name: "line1".to_string(), - field_type: enums::FieldType::UserAddressLine1, - value: None, - } - ), - ( - "billing.address.city".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.city".to_string(), - display_name: "city".to_string(), - field_type: enums::FieldType::UserAddressCity, - value: None, - } - ), - ( - "billing.address.state".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.state".to_string(), - display_name: "state".to_string(), - field_type: enums::FieldType::UserAddressState, - value: None, - } - ), - ( - "billing.address.zip".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.zip".to_string(), - display_name: "zip".to_string(), - field_type: enums::FieldType::UserAddressPincode, - value: None, - } - ), - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserAddressCountry{ - options: vec![ - "ALL".to_string(), - ] - }, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "first_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "last_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ) - ] - ), - common: HashMap::new(), - } - ), - ( - enums::Connector::Dlocal, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserAddressCountry{ - options: vec![ - "ALL".to_string(), - ] - }, - value: None, - } - ) - ] - ), - common:HashMap::new(), - } - ), - #[cfg(feature = "dummy_connector")] - ( - enums::Connector::DummyConnector1, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ) - ] - ), - } - ), - #[cfg(feature = "dummy_connector")] - ( - enums::Connector::DummyConnector2, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ) - ] - ), - } - ), - #[cfg(feature = "dummy_connector")] - ( - enums::Connector::DummyConnector3, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ) - ] - ), - } - ), - #[cfg(feature = "dummy_connector")] - ( - enums::Connector::DummyConnector4, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ) - ] - ), - } - ), - #[cfg(feature = "dummy_connector")] - ( - enums::Connector::DummyConnector5, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ) - ] - ), - } - ), - #[cfg(feature = "dummy_connector")] - ( - enums::Connector::DummyConnector6, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ) - ] - ), - } - ), - #[cfg(feature = "dummy_connector")] - ( - enums::Connector::DummyConnector7, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ) - ] - ), - } - ), - ( - enums::Connector::Elavon, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ), - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - - ] - ), - common: HashMap::new(), - } - ), - ( - enums::Connector::Fiserv, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ) - ] - ), - common: HashMap::new(), - } - ), - ( - enums::Connector::Fiuu, - RequiredFieldFinal { - mandate: HashMap::from([ - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ]), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ) - ] - ), - } - ), - ( - enums::Connector::Forte, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ] - ), - common:HashMap::new(), - } - ), - ( - enums::Connector::Globalpay, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from([ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ) - ]), - } - ), - ( - enums::Connector::Hipay, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "billing.address.city".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.city".to_string(), - display_name: "city".to_string(), - field_type: enums::FieldType::UserAddressCity, - value: None, - } - ), - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "billing.address.state".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.state".to_string(), - display_name: "state".to_string(), - field_type: enums::FieldType::UserAddressState, - value: None, - } - ), - ( - "billing.address.zip".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.zip".to_string(), - display_name: "zip".to_string(), - field_type: enums::FieldType::UserAddressPincode, - value: None, - } - ), - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserAddressCountry{ - options: vec![ - "ALL".to_string(), - ] - }, - value: None, - } - ), - ( - "billing.address.line1".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.line1".to_string(), - display_name: "line1".to_string(), - field_type: enums::FieldType::UserAddressLine1, - value: None, - } - ), - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ] - ), - } - ), - ( - enums::Connector::Helcim, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.zip".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.zip".to_string(), - display_name: "zip".to_string(), - field_type: enums::FieldType::UserAddressPincode, - value: None, - } - ), - ( - "billing.address.line1".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.line1".to_string(), - display_name: "line1".to_string(), - field_type: enums::FieldType::UserAddressLine1, - value: None, - } - ), - ] - ), - common: HashMap::new(), - } - ), - ( - enums::Connector::Iatapay, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::new(), - } - ), - ( - enums::Connector::Mollie, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ] - ), - common: HashMap::new(), - } - ), - ( - enums::Connector::Moneris, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ), - ] - ), - common: HashMap::new(), - } - ), - ( - enums::Connector::Multisafepay, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate:HashMap::new(), - common: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.line1".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.line1".to_string(), - display_name: "line1".to_string(), - field_type: enums::FieldType::UserAddressLine1, - value: None, - } - ), - ( - "billing.address.line2".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.line2".to_string(), - display_name: "line2".to_string(), - field_type: enums::FieldType::UserAddressLine2, - value: None, - } - ), - ( - "billing.address.city".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.city".to_string(), - display_name: "city".to_string(), - field_type: enums::FieldType::UserAddressCity, - value: None, - } - ), - ( - "billing.address.zip".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.zip".to_string(), - display_name: "zip".to_string(), - field_type: enums::FieldType::UserAddressPincode, - value: None, - } - ), - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserAddressCountry{ - options: vec![ - "ALL".to_string(), - ] - }, - value: None, - } - ) - ] - ), - } - ), - ( - enums::Connector::Nexinets, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ) - ] - ), - } - ), - ( - enums::Connector::Nexixpay, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "first_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "last_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ) - ] - ), - } - ), - ( - enums::Connector::Nmi, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.zip".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.zip".to_string(), - display_name: "billing_zip".to_string(), - field_type: enums::FieldType::UserAddressPincode, - value: None, - } - ), - ] - ), - common: HashMap::new(), - } - ), - ( - enums::Connector::Noon, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ] - ), - } - ), - ( - enums::Connector::Novalnet, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "first_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "last_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email_address".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ] - ), - } - ), - ( - enums::Connector::Nuvei, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ) - ] - ), - } - ), - ( - enums::Connector::Paybox, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "email".to_string(), - RequiredFieldInfo { - required_field: "email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.line1".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.line1".to_string(), - display_name: "line1".to_string(), - field_type: enums::FieldType::UserAddressLine1, - value: None, - } - ), - ( - "billing.address.city".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.city".to_string(), - display_name: "city".to_string(), - field_type: enums::FieldType::UserAddressCity, - value: None, - } - ), - ( - "billing.address.zip".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.zip".to_string(), - display_name: "zip".to_string(), - field_type: enums::FieldType::UserAddressPincode, - value: None, - } - ), - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserAddressCountry{ - options: vec![ - "ALL".to_string(), - ] - }, - value: None, - } - ) - - ] - ), - } - ), - ( - enums::Connector::Payme, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ), - ( - "email".to_string(), - RequiredFieldInfo { - required_field: "email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ] - ), - } - ), - ( - enums::Connector::Paypal, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ) - ] - ), - common: HashMap::new(), - } - ), - ( - enums::Connector::Payu, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ) - ] - ), - common: HashMap::new(), - } - ), - ( - enums::Connector::Powertranz, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ] - ), - common: HashMap::new(), - } - ), - ( - enums::Connector::Rapyd, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ] - ), - common: HashMap::new(), - } - ), - ( - enums::Connector::Redsys, - RequiredFieldFinal { - mandate: HashMap::new(), - common: HashMap::new(), - non_mandate: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ) - ] - ), - } - ), - ( - enums::Connector::Shift4, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ) - ] - ), - common: HashMap::new(), - } - ), - ( - enums::Connector::Square, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ) - ] - ), - } - ), - ( - enums::Connector::Stax, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ] - ), - common: HashMap::new(), - } - ), - ( - enums::Connector::Stripe, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common:HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ) - ] - ), - } - ), - ( - enums::Connector::Trustpay, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.line1".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.line1".to_string(), - display_name: "line1".to_string(), - field_type: enums::FieldType::UserAddressLine1, - value: None, - } - ), - ( - "billing.address.city".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.city".to_string(), - display_name: "city".to_string(), - field_type: enums::FieldType::UserAddressCity, - value: None, - } - ), - ( - "billing.address.zip".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.zip".to_string(), - display_name: "zip".to_string(), - field_type: enums::FieldType::UserAddressPincode, - value: None, - } - ), - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserAddressCountry{ - options: vec![ - "ALL".to_string(), - ] - }, - value: None, - } - ), - ] - ), - common: HashMap::new() - } - ), - ( - enums::Connector::Tsys, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ) - ] - ), - common: HashMap::new() - } - ), - ( - enums::Connector::Wellsfargo, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common:HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "email".to_string(), - RequiredFieldInfo { - required_field: "email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "billing.address.line1".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.line1".to_string(), - display_name: "line1".to_string(), - field_type: enums::FieldType::UserAddressLine1, - value: None, - } - ), - ( - "billing.address.city".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.city".to_string(), - display_name: "city".to_string(), - field_type: enums::FieldType::UserAddressCity, - value: None, - } - ), - ( - "billing.address.state".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.state".to_string(), - display_name: "state".to_string(), - field_type: enums::FieldType::UserAddressState, - value: None, - } - ), - ( - "billing.address.zip".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.zip".to_string(), - display_name: "zip".to_string(), - field_type: enums::FieldType::UserAddressPincode, - value: None, - } - ), - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserAddressCountry{ - options: vec![ - "ALL".to_string(), - ] - }, - value: None, - } - ) - ] - ), - } - ), - ( - enums::Connector::Worldline, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from([ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ), - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserAddressCountry{ - options: vec![ - "ALL".to_string(), - ] - }, - value: None, - } - ) - ]), - common: HashMap::new(), - } - ), - ( - enums::Connector::Worldpay, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: { - let mut pmd_fields = HashMap::from([ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ) - ]); - pmd_fields.extend(get_worldpay_billing_required_fields()); - pmd_fields - }, - } - ), - ( - enums::Connector::Xendit, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate:HashMap::new(), - common: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ), - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "billing.phone.number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.phone.number".to_string(), - display_name: "phone_number".to_string(), - field_type: enums::FieldType::UserPhoneNumber, - value: None, - } - ) - - ] - ), - } - ), - ( - enums::Connector::Zen, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from([ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "email".to_string(), - RequiredFieldInfo { - required_field: "email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ]), - common: HashMap::new(), - } - ), - ]), - }, - ), - ( - enums::PaymentMethodType::Credit, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Aci, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ] - ), - } - ), - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ] - ), - } - ), - ( - enums::Connector::Airwallex, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ) - ] - ), - common: HashMap::new(), - } - ), - ( - enums::Connector::Authorizedotnet, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ) - ] - ), - } - ), - ( - enums::Connector::Bambora, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ) - ] - ), - common: HashMap::new(), - } - ), - ( - enums::Connector::Bankofamerica, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ), - ( - "email".to_string(), - RequiredFieldInfo { - required_field: "email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.city".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.city".to_string(), - display_name: "city".to_string(), - field_type: enums::FieldType::UserAddressCity, - value: None, - } - ), - ( - "billing.address.state".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.state".to_string(), - display_name: "state".to_string(), - field_type: enums::FieldType::UserAddressState, - value: None, - } - ), - ( - "billing.address.zip".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.zip".to_string(), - display_name: "zip".to_string(), - field_type: enums::FieldType::UserAddressPincode, - value: None, - } - ), - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserAddressCountry{ - options: vec![ - "ALL".to_string(), - ] - }, - value: None, - } - ), - ( - "billing.address.line1".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.line1".to_string(), - display_name: "line1".to_string(), - field_type: enums::FieldType::UserAddressLine1, - value: None, - } - ), - ] - ), - } - ), - ( - enums::Connector::Billwerk, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ) - ] - ), - } - ), - ( - enums::Connector::Bluesnap, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ), - ( - "email".to_string(), - RequiredFieldInfo { - required_field: "email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ) - ] - ), - common: HashMap::new(), - } - ), - ( - enums::Connector::Boku, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ) - ] - ), - } - ), - ( - enums::Connector::Braintree, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ) - ] - ), - } - ), - ( - enums::Connector::Checkout, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ) - ] - ), - common: HashMap::new(), - } - ), - ( - enums::Connector::Coinbase, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from( - [ - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ) - ] - ), - common: HashMap::new(), - } - ), - ( - enums::Connector::Cybersource, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate:HashMap::new(), - common: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "billing.address.line1".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.line1".to_string(), - display_name: "line1".to_string(), - field_type: enums::FieldType::UserAddressLine1, - value: None, - } - ), - ( - "billing.address.city".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.city".to_string(), - display_name: "city".to_string(), - field_type: enums::FieldType::UserAddressCity, - value: None, - } - ), - ( - "billing.address.state".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.state".to_string(), - display_name: "state".to_string(), - field_type: enums::FieldType::UserAddressState, - value: None, - } - ), - ( - "billing.address.zip".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.zip".to_string(), - display_name: "zip".to_string(), - field_type: enums::FieldType::UserAddressPincode, - value: None, - } - ), - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserAddressCountry{ - options: vec![ - "ALL".to_string(), - ] - }, - value: None, - } - ) - ] - ), - } - ), - ( - enums::Connector::Datatrans, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ] - ), - } - ), - ( - enums::Connector::Deutschebank, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate : HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ), - ( - "email".to_string(), - RequiredFieldInfo { - required_field: "email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "billing.address.line1".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.line1".to_string(), - display_name: "line1".to_string(), - field_type: enums::FieldType::UserAddressLine1, - value: None, - } - ), - ( - "billing.address.city".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.city".to_string(), - display_name: "city".to_string(), - field_type: enums::FieldType::UserAddressCity, - value: None, - } - ), - ( - "billing.address.state".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.state".to_string(), - display_name: "state".to_string(), - field_type: enums::FieldType::UserAddressState, - value: None, - } - ), - ( - "billing.address.zip".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.zip".to_string(), - display_name: "zip".to_string(), - field_type: enums::FieldType::UserAddressPincode, - value: None, - } - ), - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserAddressCountry{ - options: vec![ - "ALL".to_string(), - ] - }, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "first_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "last_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ) - ] - ), - common: HashMap::new(), - } - ), - ( - enums::Connector::Dlocal, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserAddressCountry{ - options: vec![ - "ALL".to_string(), - ] - }, - value: None, - } - ) - ] - ), - common:HashMap::new(), - } - ), - #[cfg(feature = "dummy_connector")] - ( - enums::Connector::DummyConnector1, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ) - ] - ), - } - ), - #[cfg(feature = "dummy_connector")] - ( - enums::Connector::DummyConnector2, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ) - ] - ), - } - ), - #[cfg(feature = "dummy_connector")] - ( - enums::Connector::DummyConnector3, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ) - ] - ), - } - ), - #[cfg(feature = "dummy_connector")] - ( - enums::Connector::DummyConnector4, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ) - ] - ), - } - ), - #[cfg(feature = "dummy_connector")] - ( - enums::Connector::DummyConnector5, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ) - ] - ), - } - ), - #[cfg(feature = "dummy_connector")] - ( - enums::Connector::DummyConnector6, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ) - ] - ), - } - ), - #[cfg(feature = "dummy_connector")] - ( - enums::Connector::DummyConnector7, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ) - ] - ), - } - ), - ( - enums::Connector::Elavon, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ), - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - - ] - ), - common: HashMap::new(), - } - ), - ( - enums::Connector::Fiserv, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ) - ] - ), - common: HashMap::new(), - } - ), - ( - enums::Connector::Fiuu, - RequiredFieldFinal { - mandate: HashMap::from([ - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ]), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ) - ] - ), - } - ), - ( - enums::Connector::Forte, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ] - ), - common:HashMap::new(), - } - ), - ( - enums::Connector::Getnet, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ), - ( - "payment_method_data.card.card_network".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_network".to_string(), - display_name: "card_network".to_string(), - field_type: enums::FieldType::UserCardNetwork, - value: None, - } - ), - ] - ), - } - ), - ( - enums::Connector::Globalpay, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from([ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ) - ]), - } - ), - ( - enums::Connector::Hipay, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "billing.address.city".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.city".to_string(), - display_name: "city".to_string(), - field_type: enums::FieldType::UserAddressCity, - value: None, - } - ), - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "billing.address.state".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.state".to_string(), - display_name: "state".to_string(), - field_type: enums::FieldType::UserAddressState, - value: None, - } - ), - ( - "billing.address.zip".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.zip".to_string(), - display_name: "zip".to_string(), - field_type: enums::FieldType::UserAddressPincode, - value: None, - } - ), - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserAddressCountry{ - options: vec![ - "ALL".to_string(), - ] - }, - value: None, - } - ), - ( - "billing.address.line1".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.line1".to_string(), - display_name: "line1".to_string(), - field_type: enums::FieldType::UserAddressLine1, - value: None, - } - ), - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ] - ), - } - ), - ( - enums::Connector::Helcim, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.zip".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.zip".to_string(), - display_name: "zip".to_string(), - field_type: enums::FieldType::UserAddressPincode, - value: None, - } - ), - ( - "billing.address.line1".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.line1".to_string(), - display_name: "line1".to_string(), - field_type: enums::FieldType::UserAddressLine1, - value: None, - } - ), - ] - ), - common: HashMap::new(), - } - ), - ( - enums::Connector::Iatapay, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::new(), - } - ), - ( - enums::Connector::Mollie, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ] - ), - common: HashMap::new(), - } - ), - ( - enums::Connector::Moneris, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ), - ] - ), - common: HashMap::new(), - } - ), - ( - enums::Connector::Multisafepay, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate:HashMap::new(), - common: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.line1".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.line1".to_string(), - display_name: "line1".to_string(), - field_type: enums::FieldType::UserAddressLine1, - value: None, - } - ), - ( - "billing.address.line2".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.line2".to_string(), - display_name: "line2".to_string(), - field_type: enums::FieldType::UserAddressLine2, - value: None, - } - ), - ( - "billing.address.city".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.city".to_string(), - display_name: "city".to_string(), - field_type: enums::FieldType::UserAddressCity, - value: None, - } - ), - ( - "billing.address.zip".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.zip".to_string(), - display_name: "zip".to_string(), - field_type: enums::FieldType::UserAddressPincode, - value: None, - } - ), - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserAddressCountry{ - options: vec![ - "ALL".to_string(), - ] - }, - value: None, - } - ) - ] - ), - } - ), - ( - enums::Connector::Nexinets, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ) - ] - ), - } - ), - ( - enums::Connector::Nexixpay, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "first_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "last_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ) - ] - ), - } - ), - ( - enums::Connector::Nmi, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.zip".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.zip".to_string(), - display_name: "billing_zip".to_string(), - field_type: enums::FieldType::UserAddressPincode, - value: None, - } - ), - ] - ), - common: HashMap::new(), - } - ), - ( - enums::Connector::Noon, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ] - ), - } - ), - ( - enums::Connector::Novalnet, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "first_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "last_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email_address".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ] - ), - } - ), - ( - enums::Connector::Nuvei, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ) - ] - ), - } - ),( - enums::Connector::Paybox, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "email".to_string(), - RequiredFieldInfo { - required_field: "email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.line1".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.line1".to_string(), - display_name: "line1".to_string(), - field_type: enums::FieldType::UserAddressLine1, - value: None, - } - ), - ( - "billing.address.city".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.city".to_string(), - display_name: "city".to_string(), - field_type: enums::FieldType::UserAddressCity, - value: None, - } - ), - ( - "billing.address.zip".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.zip".to_string(), - display_name: "zip".to_string(), - field_type: enums::FieldType::UserAddressPincode, - value: None, - } - ), - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserAddressCountry{ - options: vec![ - "ALL".to_string(), - ] - }, - value: None, - } - ) - - ] - ), - } - ), - ( - enums::Connector::Payme, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ), - ( - "email".to_string(), - RequiredFieldInfo { - required_field: "email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ] - ), - } - ), - ( - enums::Connector::Paypal, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ) - ] - ), - common: HashMap::new(), - } - ), - ( - enums::Connector::Payu, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ) - ] - ), - common: HashMap::new(), - } - ), - ( - enums::Connector::Powertranz, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ] - ), - common: HashMap::new(), - } - ), - ( - enums::Connector::Rapyd, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ] - ), - common: HashMap::new(), - } - ), - ( - enums::Connector::Redsys, - RequiredFieldFinal { - mandate: HashMap::new(), - common: HashMap::new(), - non_mandate: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ) - ] - ), - } - ), - ( - enums::Connector::Shift4, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ) - ] - ), - common: HashMap::new(), - } - ), - ( - enums::Connector::Square, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ) - ] - ), - } - ), - ( - enums::Connector::Stax, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ] - ), - common: HashMap::new(), - } - ), - ( - enums::Connector::Stripe, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common:HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ) - ] - ), - } - ), - ( - enums::Connector::Trustpay, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.line1".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.line1".to_string(), - display_name: "line1".to_string(), - field_type: enums::FieldType::UserAddressLine1, - value: None, - } - ), - ( - "billing.address.city".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.city".to_string(), - display_name: "city".to_string(), - field_type: enums::FieldType::UserAddressCity, - value: None, - } - ), - ( - "billing.address.zip".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.zip".to_string(), - display_name: "zip".to_string(), - field_type: enums::FieldType::UserAddressPincode, - value: None, - } - ), - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserAddressCountry{ - options: vec![ - "ALL".to_string(), - ] - }, - value: None, - } - ), - ] - ), - common: HashMap::new() - } - ), - ( - enums::Connector::Tsys, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ) - ] - ), - common: HashMap::new() - } - ), - ( - enums::Connector::Wellsfargo, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate:HashMap::new(), - common: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "email".to_string(), - RequiredFieldInfo { - required_field: "email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "billing.address.line1".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.line1".to_string(), - display_name: "line1".to_string(), - field_type: enums::FieldType::UserAddressLine1, - value: None, - } - ), - ( - "billing.address.city".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.city".to_string(), - display_name: "city".to_string(), - field_type: enums::FieldType::UserAddressCity, - value: None, - } - ), - ( - "billing.address.state".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.state".to_string(), - display_name: "state".to_string(), - field_type: enums::FieldType::UserAddressState, - value: None, - } - ), - ( - "billing.address.zip".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.zip".to_string(), - display_name: "zip".to_string(), - field_type: enums::FieldType::UserAddressPincode, - value: None, - } - ), - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserAddressCountry{ - options: vec![ - "ALL".to_string(), - ] - }, - value: None, - } - ) - ] - ), - } - ), - ( - enums::Connector::Worldline, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from([ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ), - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserAddressCountry{ - options: vec![ - "ALL".to_string(), - ] - }, - value: None, - } - ) - ]), - common: HashMap::new(), - } - ), - ( - enums::Connector::Worldpay, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: { - let mut pmd_fields = HashMap::from([ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ) - ]); - pmd_fields.extend(get_worldpay_billing_required_fields()); - pmd_fields - }, - } - ), - ( - enums::Connector::Xendit, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate:HashMap::new(), - common: HashMap::from( - [ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "payment_method_data.card.card_cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_cvc".to_string(), - display_name: "card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ), - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "billing.phone.number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.phone.number".to_string(), - display_name: "phone_number".to_string(), - field_type: enums::FieldType::UserPhoneNumber, - value: None, - } - ) - - ] - ), - } - ), - ( - enums::Connector::Zen, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from([ - ( - "payment_method_data.card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "email".to_string(), - RequiredFieldInfo { - required_field: "email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ]), - common: HashMap::new(), - } - ), - ]), - }, - ), - - ])), - ), - ( - enums::PaymentMethod::BankRedirect, - PaymentMethodType(HashMap::from([ - ( - enums::PaymentMethodType::OpenBankingUk, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Volt, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from([ - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "billing_first_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "billing_last_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ), - ]), - common: HashMap::new(), - } - ), - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap:: from([ - ( - "payment_method_data.bank_redirect.open_banking_uk.issuer".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.bank_redirect.open_banking_uk.issuer".to_string(), - display_name: "issuer".to_string(), - field_type: enums::FieldType::UserBank, - value: None, - } - ) - ]), - common: HashMap::new(), - } - ) - ]), - }, - ), - ( - enums::PaymentMethodType::Trustly, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::new(), - } - ) - ]), - }, - ), - ( - enums::PaymentMethodType::OnlineBankingCzechRepublic, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from([ - ( - "payment_method_data.bank_redirect.open_banking_czech_republic.issuer".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.bank_redirect.open_banking_czech_republic.issuer".to_string(), - display_name: "issuer".to_string(), - field_type: enums::FieldType::UserBank, - value: None, - } - ) - ]), - common: HashMap::new(), - } - ) - ]), - }, - ), - ( - enums::PaymentMethodType::OnlineBankingFinland, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from([ - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ]), - common: HashMap::new(), - } - ) - ]), - }, - ), - ( - enums::PaymentMethodType::OnlineBankingPoland, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from([ - ( - "payment_method_data.bank_redirect.open_banking_poland.issuer".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.bank_redirect.open_banking_poland.issuer".to_string(), - display_name: "issuer".to_string(), - field_type: enums::FieldType::UserBank, - value: None, - } - ), - - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ]), - common: HashMap::new(), - } - ) - ]), - }, - ), - ( - enums::PaymentMethodType::OnlineBankingSlovakia, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from([ - ( - "payment_method_data.bank_redirect.open_banking_slovakia.issuer".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.bank_redirect.open_banking_slovakia.issuer".to_string(), - display_name: "issuer".to_string(), - field_type: enums::FieldType::UserBank, - value: None, - } - ), - ]), - common: HashMap::new(), - } - ) - ]), - }, - ), - ( - enums::PaymentMethodType::OnlineBankingFpx, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from([ - ( - "payment_method_data.bank_redirect.open_banking_fpx.issuer".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.bank_redirect.open_banking_fpx.issuer".to_string(), - display_name: "issuer".to_string(), - field_type: enums::FieldType::UserBank, - value: None, - } - ) - ]), - common: HashMap::new(), - } - ) - ]), - }, - ), - ( - enums::PaymentMethodType::OnlineBankingThailand, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from([ - ( - "payment_method_data.bank_redirect.open_banking_thailand.issuer".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.bank_redirect.open_banking_thailand.issuer".to_string(), - display_name: "issuer".to_string(), - field_type: enums::FieldType::UserBank, - value: None, - } - ) - ]), - common: HashMap::new(), - } - ) - ]), - }, - ), - ( - enums::PaymentMethodType::Bizum, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::new(), - } - ) - ]), - }, - ), - ( - enums::PaymentMethodType::Przelewy24, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Stripe, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from([ - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ) - ]), - common: HashMap::new(), - } - )]), - }, - ), - ( - enums::PaymentMethodType::BancontactCard, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Mollie, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::new(), - } - ), - ( - enums::Connector::Stripe, - RequiredFieldFinal { - mandate: HashMap::from([ - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ) - ]), - non_mandate: HashMap::new(), - common: HashMap::from([ - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "billing_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "billing_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ]), - } - ), - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from([ - ( - "payment_method_data.bank_redirect.bancontact_card.card_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.bank_redirect.bancontact_card.card_number".to_string(), - display_name: "card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.bank_redirect.bancontact_card.card_exp_month".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.bank_redirect.bancontact_card.card_exp_month".to_string(), - display_name: "card_exp_month".to_string(), - field_type: enums::FieldType::UserCardExpiryMonth, - value: None, - } - ), - ( - "payment_method_data.bank_redirect.bancontact_card.card_exp_year".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.bank_redirect.bancontact_card.card_exp_year".to_string(), - display_name: "card_exp_year".to_string(), - field_type: enums::FieldType::UserCardExpiryYear, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ]), - } - ) - ]), - }, - ), - ( - enums::PaymentMethodType::Giropay, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Aci, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from([ - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserCountry { - options: vec![ - "DE".to_string(), - ]}, - value: None, - } - ) - ]), - common: HashMap::new(), - } - ), - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::new(), - } - ), - ( - enums::Connector::Globalpay, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from([ - ("billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserAddressCountry { - options: vec![ - "DE".to_string(), - ] - }, - value: None, - } - ) - ]), - } - ), - ( - enums::Connector::Mollie, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::new(), - } - ), - ( - enums::Connector::Nuvei, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate:HashMap::from([ - ( - "email".to_string(), - RequiredFieldInfo { - required_field: "email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "billing_first_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "billing_last_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ), - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserAddressCountry{ - options: vec![ - "DE".to_string(), - ] - }, - value: None, - } - )] - ), - common: HashMap::new(), - } - ), - ( - enums::Connector::Paypal, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from([ - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserCountry { - options: vec![ - "DE".to_string(), - ] - }, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "billing_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "billing_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ) - ]), - common: HashMap::new(), - } - ), - ( - enums::Connector::Stripe, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from([ - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "billing_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "billing_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ) - ]), - common: HashMap::new(), - } - ), - ( - enums::Connector::Shift4, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::new(), - } - ), - ( - enums::Connector::Trustpay, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from([ - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "billing_first_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ), - ( - "billing.address.line1".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.line1".to_string(), - display_name: "line1".to_string(), - field_type: enums::FieldType::UserAddressLine1, - value: None, - } - ), - ( - "billing.address.city".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.city".to_string(), - display_name: "city".to_string(), - field_type: enums::FieldType::UserAddressCity, - value: None, - } - ), - ( - "billing.address.zip".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.zip".to_string(), - display_name: "zip".to_string(), - field_type: enums::FieldType::UserAddressPincode, - value: None, - } - ), - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserAddressCountry { - options: vec![ - "DE".to_string(), - ] - }, - value: None, - } - ), - ]), - common: HashMap::new(), - } - ), - ]), - }, - ), - ( - enums::PaymentMethodType::Ideal, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Aci, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from([ - ( - "payment_method_data.bank_redirect.ideal.bank_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.bank_redirect.ideal.bank_name".to_string(), - display_name: "bank_name".to_string(), - field_type: enums::FieldType::UserBank, - value: None, - } - ), - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserCountry { - options: vec![ - "NL".to_string(), - ] - }, - value: None, - } - ) - ]), - common: HashMap::new(), - } - ), - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from([ - ( - "payment_method_data.bank_redirect.ideal.bank_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.bank_redirect.ideal.bank_name".to_string(), - display_name: "bank_name".to_string(), - field_type: enums::FieldType::UserBank, - value: None, - } - ), - - ]), - } - ), - ( - enums::Connector::Globalpay, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::new(), - } - ), - ( - enums::Connector::Mollie, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::new(), - } - ), - ( - enums::Connector::Nexinets, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::new(), - } - ), - ( - enums::Connector::Nuvei, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from([ - ( - "email".to_string(), - RequiredFieldInfo { - required_field: "email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "billing_first_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "billing_last_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ), - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserAddressCountry{ - options: vec![ - "NL".to_string(), - ] - }, - value: None, - } - ) - ]), - common: HashMap::new(), - } - ), - ( - enums::Connector::Shift4, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from([ - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserCountry{ - options: vec![ - "NL".to_string(), - ] - }, - value: None, - } - ) - ]), - common: HashMap::new(), - } - ), - ( - enums::Connector::Paypal, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from([ - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "billing_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "billing_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ), - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserCountry{ - options: vec![ - "NL".to_string(), - ] - }, - value: None, - } - ) - ]), - common: HashMap::new(), - } - ), - ( - enums::Connector::Stripe, - RequiredFieldFinal { - mandate: HashMap::from([ - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "billing_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "billing_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "billing_email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ) - ]), - non_mandate: HashMap::new(), - common: HashMap::new(), - } - ), - ( - enums::Connector::Trustpay, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from([ - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "billing_first_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ), - ( - "billing.address.line1".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.line1".to_string(), - display_name: "line1".to_string(), - field_type: enums::FieldType::UserAddressLine1, - value: None, - } - ), - ( - "billing.address.city".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.city".to_string(), - display_name: "city".to_string(), - field_type: enums::FieldType::UserAddressCity, - value: None, - } - ), - ( - "billing.address.zip".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.zip".to_string(), - display_name: "zip".to_string(), - field_type: enums::FieldType::UserAddressPincode, - value: None, - } - ), - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserAddressCountry{ - options: vec![ - "NL".to_string(), - ] - }, - value: None, - } - ), - ]), - common: HashMap::new(), - } - ), - ]), - }, - ), - ( - enums::PaymentMethodType::Sofort, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Aci, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from([ - ("billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserCountry { - options: vec![ - "ES".to_string(), - "GB".to_string(), - "SE".to_string(), - "AT".to_string(), - "NL".to_string(), - "DE".to_string(), - "CH".to_string(), - "BE".to_string(), - "FR".to_string(), - "FI".to_string(), - "IT".to_string(), - "PL".to_string(), - ] - }, - value: None, - } - ) - ]), - common: HashMap::new(), - } - ), - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::new(), - } - ), - ( - enums::Connector::Globalpay, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from([ - ("billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserAddressCountry { - options: vec![ - "AT".to_string(), - "BE".to_string(), - "DE".to_string(), - "ES".to_string(), - "IT".to_string(), - "NL".to_string(), - ] - }, - value: None, - } - ) - ]), - } - ), - ( - enums::Connector::Mollie, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::new(), - } - ), - ( - enums::Connector::Nexinets, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::new(), - } - ), - ( - enums::Connector::Nuvei, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate:HashMap::from([ - ( - "email".to_string(), - RequiredFieldInfo { - required_field: "email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "billing_first_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "billing_last_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ), - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserAddressCountry{ - options: vec![ - "ES".to_string(), - "GB".to_string(), - "IT".to_string(), - "DE".to_string(), - "FR".to_string(), - "AT".to_string(), - "BE".to_string(), - "NL".to_string(), - "BE".to_string(), - "SK".to_string(), - ] - }, - value: None, - } - )] - ), - common: HashMap::new(), - } - ), - ( - enums::Connector::Paypal, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from([ - ( "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserCountry { - options: vec![ - "ES".to_string(), - "GB".to_string(), - "AT".to_string(), - "NL".to_string(), - "DE".to_string(), - "BE".to_string(), - ] - }, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "billing_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "billing_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ) - ]), - common: HashMap::new(), - } - ), - ( - enums::Connector::Shift4, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::new(), - } - ), - ( - enums::Connector::Stripe, - RequiredFieldFinal { - mandate: HashMap::from([ - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ) - ]), - non_mandate : HashMap::new(), - common: HashMap::from([ - ("billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserCountry { - options: vec![ - "ES".to_string(), - "AT".to_string(), - "NL".to_string(), - "DE".to_string(), - "BE".to_string(), - ] - }, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "account_holder_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "account_holder_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - )]), - } - ), - ( - enums::Connector::Trustpay, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from([ - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "billing_first_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ), - ( - "billing.address.line1".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.line1".to_string(), - display_name: "line1".to_string(), - field_type: enums::FieldType::UserAddressLine1, - value: None, - } - ), - ( - "billing.address.city".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.city".to_string(), - display_name: "city".to_string(), - field_type: enums::FieldType::UserAddressCity, - value: None, - } - ), - ( - "billing.address.zip".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.zip".to_string(), - display_name: "zip".to_string(), - field_type: enums::FieldType::UserAddressPincode, - value: None, - } - ), - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserAddressCountry { - options: vec![ - "ES".to_string(), - "GB".to_string(), - "SE".to_string(), - "AT".to_string(), - "NL".to_string(), - "DE".to_string(), - "CH".to_string(), - "BE".to_string(), - "FR".to_string(), - "FI".to_string(), - "IT".to_string(), - "PL".to_string(), - ] - }, - value: None, - } - ), - ]), - common: HashMap::new(), - } - ), - ]), - }, - ), - ( - enums::PaymentMethodType::Eps, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from([ - ( - "payment_method_data.bank_redirect.eps.bank_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.bank_redirect.eps.bank_name".to_string(), - display_name: "bank_name".to_string(), - field_type: enums::FieldType::UserBank, - value: None, - } - ) - ]), - } - ), - ( - enums::Connector::Stripe, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from([ - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "billing_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "billing_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ]), - common: HashMap::new(), - } - ), - ( - enums::Connector::Aci, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from([ - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "bank_account_country".to_string(), - field_type: enums::FieldType::UserCountry { - options: vec![ - "AT".to_string(), - ] - }, - value: None, - } - ) - ]), - common: HashMap::new(), - } - ), - ( - enums::Connector::Globalpay, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from([ - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserAddressCountry { - options: vec![ - "AT".to_string(), - ] - }, - value: None, - } - ) - ]) - } - ), - ( - enums::Connector::Mollie, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate:HashMap::new(), - common: HashMap::new(), - } - ), - ( - enums::Connector::Paypal, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from([ - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "billing_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "billing_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "bank_account_country".to_string(), - field_type: enums::FieldType::UserCountry { - options: vec![ - "AT".to_string(), - ] - }, - value: None, - } - ) - ]), - common: HashMap::new(), - } - ), - ( - enums::Connector::Trustpay, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from([ - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "billing_first_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ), - ( - "billing.address.line1".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.line1".to_string(), - display_name: "line1".to_string(), - field_type: enums::FieldType::UserAddressLine1, - value: None, - } - ), - ( - "billing.address.city".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.city".to_string(), - display_name: "city".to_string(), - field_type: enums::FieldType::UserAddressCity, - value: None, - } - ), - ( - "billing.address.zip".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.zip".to_string(), - display_name: "zip".to_string(), - field_type: enums::FieldType::UserAddressPincode, - value: None, - } - ), - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserAddressCountry{ - options: vec![ - "AT".to_string(), - ] - }, - value: None, - } - ), - ]), - common: HashMap::new(), - } - ), - ( - enums::Connector::Shift4, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate:HashMap::new(), - common: HashMap::new(), - } - ), - ( - enums::Connector::Nuvei, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from([ - ( - "email".to_string(), - RequiredFieldInfo { - required_field: "email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "billing_first_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "billing_last_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ), - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserAddressCountry{ - options: vec![ - "AT".to_string(), - ] - }, - value: None, - } - )] - ), - common: HashMap::new(), - } - ), - ]), - }, - ), - ( - enums::PaymentMethodType::Blik, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from([ - ( - "payment_method_data.bank_redirect.blik.blik_code".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.bank_redirect.blik.blik_code".to_string(), - display_name: "blik_code".to_string(), - field_type: enums::FieldType::UserBlikCode, - value: None, - } - ) - ]), - } - ), - ( - enums::Connector::Stripe, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from([ - ( - "payment_method_data.bank_redirect.blik.blik_code".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.bank_redirect.blik.blik_code".to_string(), - display_name: "blik_code".to_string(), - field_type: enums::FieldType::UserBlikCode, - value: None, - } - ) - ]), - } - ), - ( - enums::Connector::Trustpay, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from([ - ( - "email".to_string(), - RequiredFieldInfo { - required_field: "email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "billing_first_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "billing_last_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ), - ( - "billing.address.line1".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.line1".to_string(), - display_name: "line1".to_string(), - field_type: enums::FieldType::UserAddressLine1, - value: None, - } - ), - ( - "billing.address.city".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.city".to_string(), - display_name: "city".to_string(), - field_type: enums::FieldType::UserAddressCity, - value: None, - } - ), - ( - "billing.address.zip".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.zip".to_string(), - display_name: "zip".to_string(), - field_type: enums::FieldType::UserAddressPincode, - value: None, - } - ), - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserAddressCountry{ - options: vec![ - "ALL".to_string(), - ] - }, - value: None, - } - ), - ]), - } - ) - ]), - }, - ), - ])), - ), - ( - enums::PaymentMethod::Wallet, - PaymentMethodType(HashMap::from([ - ( - enums::PaymentMethodType::ApplePay, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Stripe, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::new(), - } - ), - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::new(), - } - ), - ( - enums::Connector::Bankofamerica, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "email".to_string(), - RequiredFieldInfo { - required_field: "email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "billing_first_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "billing_last_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ), - ( - "billing.address.city".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.city".to_string(), - display_name: "city".to_string(), - field_type: enums::FieldType::UserAddressCity, - value: None, - } - ), - ( - "billing.address.state".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.state".to_string(), - display_name: "state".to_string(), - field_type: enums::FieldType::UserAddressState, - value: None, - } - ), - ( - "billing.address.zip".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.zip".to_string(), - display_name: "zip".to_string(), - field_type: enums::FieldType::UserAddressPincode, - value: None, - } - ), - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserAddressCountry{ - options: vec![ - "ALL".to_string(), - ] - }, - value: None, - } - ), - ( - "billing.address.line1".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.line1".to_string(), - display_name: "line1".to_string(), - field_type: enums::FieldType::UserAddressLine1, - value: None, - } - ) - ] - ), - } - ), - ( - enums::Connector::Cybersource, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "billing_first_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "billing_last_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ), - ( - "billing.address.city".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.city".to_string(), - display_name: "city".to_string(), - field_type: enums::FieldType::UserAddressCity, - value: None, - } - ), - ( - "billing.address.state".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.state".to_string(), - display_name: "state".to_string(), - field_type: enums::FieldType::UserAddressState, - value: None, - } - ), - ( - "billing.address.zip".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.zip".to_string(), - display_name: "zip".to_string(), - field_type: enums::FieldType::UserAddressPincode, - value: None, - } - ), - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserAddressCountry{ - options: vec![ - "ALL".to_string(), - ] - }, - value: None, - } - ), - ( - "billing.address.line1".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.line1".to_string(), - display_name: "line1".to_string(), - field_type: enums::FieldType::UserAddressLine1, - value: None, - } - ) - ] - ), - } - ), - ( - enums::Connector::Novalnet, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email_address".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ] - ), - } - ), - ( - enums::Connector::Wellsfargo, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "email".to_string(), - RequiredFieldInfo { - required_field: "email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "billing_first_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "billing_last_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ), - ( - "billing.address.city".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.city".to_string(), - display_name: "city".to_string(), - field_type: enums::FieldType::UserAddressCity, - value: None, - } - ), - ( - "billing.address.state".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.state".to_string(), - display_name: "state".to_string(), - field_type: enums::FieldType::UserAddressState, - value: None, - } - ), - ( - "billing.address.zip".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.zip".to_string(), - display_name: "zip".to_string(), - field_type: enums::FieldType::UserAddressPincode, - value: None, - } - ), - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserAddressCountry{ - options: vec![ - "ALL".to_string(), - ] - }, - value: None, - } - ), - ( - "billing.address.line1".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.line1".to_string(), - display_name: "line1".to_string(), - field_type: enums::FieldType::UserAddressLine1, - value: None, - } - ), - ( - "shipping.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "shipping.address.first_name".to_string(), - display_name: "shipping_first_name".to_string(), - field_type: enums::FieldType::UserShippingName, - value: None, - } - ), - ( - "shipping.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "shipping.address.last_name".to_string(), - display_name: "shipping_last_name".to_string(), - field_type: enums::FieldType::UserShippingName, - value: None, - } - ), - ( - "shipping.address.city".to_string(), - RequiredFieldInfo { - required_field: "shipping.address.city".to_string(), - display_name: "city".to_string(), - field_type: enums::FieldType::UserShippingAddressCity, - value: None, - } - ), - ( - "shipping.address.state".to_string(), - RequiredFieldInfo { - required_field: "shipping.address.state".to_string(), - display_name: "state".to_string(), - field_type: enums::FieldType::UserShippingAddressState, - value: None, - } - ), - ( - "shipping.address.zip".to_string(), - RequiredFieldInfo { - required_field: "shipping.address.zip".to_string(), - display_name: "zip".to_string(), - field_type: enums::FieldType::UserShippingAddressPincode, - value: None, - } - ), - ( - "shipping.address.country".to_string(), - RequiredFieldInfo { - required_field: "shipping.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserShippingAddressCountry{ - options: vec![ - "ALL".to_string(), - ] - }, - value: None, - } - ), - ( - "shipping.address.line1".to_string(), - RequiredFieldInfo { - required_field: "shipping.address.line1".to_string(), - display_name: "line1".to_string(), - field_type: enums::FieldType::UserShippingAddressLine1, - value: None, - } - ), - ] - ), - } - ), - - ]), - }, - ), - ( - enums::PaymentMethodType::SamsungPay, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Cybersource, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "billing_first_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "billing_last_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ), - ( - "billing.address.city".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.city".to_string(), - display_name: "city".to_string(), - field_type: enums::FieldType::UserAddressCity, - value: None, - } - ), - ( - "billing.address.state".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.state".to_string(), - display_name: "state".to_string(), - field_type: enums::FieldType::UserAddressState, - value: None, - } - ), - ( - "billing.address.zip".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.zip".to_string(), - display_name: "zip".to_string(), - field_type: enums::FieldType::UserAddressPincode, - value: None, - } - ), - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserAddressCountry{ - options: vec![ - "ALL".to_string(), - ] - }, - value: None, - } - ), - ( - "billing.address.line1".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.line1".to_string(), - display_name: "line1".to_string(), - field_type: enums::FieldType::UserAddressLine1, - value: None, - } - ) - ] - ), - } - ), - ]), - }, - ), - ( - enums::PaymentMethodType::GooglePay, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::new(), - } - ), - ( - enums::Connector::Bankofamerica, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "email".to_string(), - RequiredFieldInfo { - required_field: "email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "billing_first_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "billing_last_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ), - ( - "billing.address.city".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.city".to_string(), - display_name: "city".to_string(), - field_type: enums::FieldType::UserAddressCity, - value: None, - } - ), - ( - "billing.address.state".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.state".to_string(), - display_name: "state".to_string(), - field_type: enums::FieldType::UserAddressState, - value: None, - } - ), - ( - "billing.address.zip".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.zip".to_string(), - display_name: "zip".to_string(), - field_type: enums::FieldType::UserAddressPincode, - value: None, - } - ), - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserAddressCountry{ - options: vec![ - "ALL".to_string(), - ] - }, - value: None, - } - ), - ( - "billing.address.line1".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.line1".to_string(), - display_name: "line1".to_string(), - field_type: enums::FieldType::UserAddressLine1, - value: None, - } - ) - ] - ), - } - ), - ( - enums::Connector::Bluesnap, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::new(), - } - ), - ( - enums::Connector::Noon, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::new(), - } - ), - ( - enums::Connector::Novalnet, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email_address".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ] - ), - } - ), - ( - enums::Connector::Nuvei, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::new(), - } - ), - ( - enums::Connector::Airwallex, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::new(), - } - ), - ( - enums::Connector::Authorizedotnet, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::new(), - } - ), - ( - enums::Connector::Checkout, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::new(), - } - ), - ( - enums::Connector::Globalpay, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::new(), - } - ), - ( - enums::Connector::Multisafepay, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "billing_first_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "billing_last_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ), - ( - "billing.address.city".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.city".to_string(), - display_name: "city".to_string(), - field_type: enums::FieldType::UserAddressCity, - value: None, - } - ), - ( - "billing.address.state".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.state".to_string(), - display_name: "state".to_string(), - field_type: enums::FieldType::UserAddressState, - value: None, - } - ), - ( - "billing.address.zip".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.zip".to_string(), - display_name: "zip".to_string(), - field_type: enums::FieldType::UserAddressPincode, - value: None, - } - ), - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserAddressCountry{ - options: vec![ - "ALL".to_string(), - ] - }, - value: None, - } - ), - ( - "billing.address.line1".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.line1".to_string(), - display_name: "line1".to_string(), - field_type: enums::FieldType::UserAddressLine1, - value: None, - } - ), - ( - "billing.address.line2".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.line2".to_string(), - display_name: "line2".to_string(), - field_type: enums::FieldType::UserAddressLine2, - value: None, - } - )] - ), - } - ), - ( - enums::Connector::Cybersource, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "billing_first_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "billing_last_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ), - ( - "billing.address.city".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.city".to_string(), - display_name: "city".to_string(), - field_type: enums::FieldType::UserAddressCity, - value: None, - } - ), - ( - "billing.address.state".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.state".to_string(), - display_name: "state".to_string(), - field_type: enums::FieldType::UserAddressState, - value: None, - } - ), - ( - "billing.address.zip".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.zip".to_string(), - display_name: "zip".to_string(), - field_type: enums::FieldType::UserAddressPincode, - value: None, - } - ), - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserAddressCountry{ - options: vec![ - "ALL".to_string(), - ] - }, - value: None, - } - ), - ( - "billing.address.line1".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.line1".to_string(), - display_name: "line1".to_string(), - field_type: enums::FieldType::UserAddressLine1, - value: None, - } - ) - ] - ), - } - ), - ( - enums::Connector::Payu, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::new(), - } - ), - ( - enums::Connector::Rapyd, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::new(), - } - ), - ( - enums::Connector::Stripe, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::new(), - } - ), - ( - enums::Connector::Trustpay, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::new(), - } - ), - ( - enums::Connector::Wellsfargo, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "email".to_string(), - RequiredFieldInfo { - required_field: "email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "billing_first_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "billing_last_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ), - ( - "billing.address.city".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.city".to_string(), - display_name: "city".to_string(), - field_type: enums::FieldType::UserAddressCity, - value: None, - } - ), - ( - "billing.address.state".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.state".to_string(), - display_name: "state".to_string(), - field_type: enums::FieldType::UserAddressState, - value: None, - } - ), - ( - "billing.address.zip".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.zip".to_string(), - display_name: "zip".to_string(), - field_type: enums::FieldType::UserAddressPincode, - value: None, - } - ), - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserAddressCountry{ - options: vec![ - "ALL".to_string(), - ] - }, - value: None, - } - ), - ( - "billing.address.line1".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.line1".to_string(), - display_name: "line1".to_string(), - field_type: enums::FieldType::UserAddressLine1, - value: None, - } - ), - ( - "shipping.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "shipping.address.first_name".to_string(), - display_name: "shipping_first_name".to_string(), - field_type: enums::FieldType::UserShippingName, - value: None, - } - ), - ( - "shipping.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "shipping.address.last_name".to_string(), - display_name: "shipping_last_name".to_string(), - field_type: enums::FieldType::UserShippingName, - value: None, - } - ), - ( - "shipping.address.city".to_string(), - RequiredFieldInfo { - required_field: "shipping.address.city".to_string(), - display_name: "city".to_string(), - field_type: enums::FieldType::UserShippingAddressCity, - value: None, - } - ), - ( - "shipping.address.state".to_string(), - RequiredFieldInfo { - required_field: "shipping.address.state".to_string(), - display_name: "state".to_string(), - field_type: enums::FieldType::UserShippingAddressState, - value: None, - } - ), - ( - "shipping.address.zip".to_string(), - RequiredFieldInfo { - required_field: "shipping.address.zip".to_string(), - display_name: "zip".to_string(), - field_type: enums::FieldType::UserShippingAddressPincode, - value: None, - } - ), - ( - "shipping.address.country".to_string(), - RequiredFieldInfo { - required_field: "shipping.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserShippingAddressCountry{ - options: vec![ - "ALL".to_string(), - ] - }, - value: None, - } - ), - ( - "shipping.address.line1".to_string(), - RequiredFieldInfo { - required_field: "shipping.address.line1".to_string(), - display_name: "line1".to_string(), - field_type: enums::FieldType::UserShippingAddressLine1, - value: None, - } - ), - ] - ), - } - ), - ]), - }, - ), - ( - enums::PaymentMethodType::WeChatPay, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Stripe, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::new(), - } - ), - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::new(), - } - ), - ]), - }, - ), - ( - enums::PaymentMethodType::AliPay, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Stripe, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::new(), - } - ), - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::new(), - } - ), - ]), - }, - ), - ( - enums::PaymentMethodType::AliPayHk, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::new(), - } - ), - ]), - }, - ), - ( - enums::PaymentMethodType::AmazonPay, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Stripe, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::new(), - } - ), - ]), - }, - ), - ( - enums::PaymentMethodType::Cashapp, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Stripe, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::new(), - } - ) - ]), - }, - ), - ( - enums::PaymentMethodType::MbWay, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate: HashMap::new(), - common: HashMap::new(), - non_mandate: HashMap::from([ - ( - "billing.phone.number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.phone.number".to_string(), - display_name: "phone_number".to_string(), - field_type: enums::FieldType::UserPhoneNumber, - value: None, - } - ), - ( - "billing.phone.country_code".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.phone.country_code".to_string(), - display_name: "dialing_code".to_string(), - field_type: enums::FieldType::UserPhoneNumberCountryCode, - value: None, - } - ), - ] - ), - } - ), - ]), - }, - ), - ( - enums::PaymentMethodType::KakaoPay, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::new(), - } - ), - ]), - }, - ), - ( - enums::PaymentMethodType::Twint, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::new(), - } - ), - ]), - }, - ), - ( - enums::PaymentMethodType::Gcash, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::new(), - } - ), - ]), - }, - ), - ( - enums::PaymentMethodType::Vipps, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::new(), - } - ), - ]), - }, - ), - ( - enums::PaymentMethodType::Dana, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::new(), - } - ), - ]), - }, - ), - ( - enums::PaymentMethodType::Momo, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::new(), - } - ), - ]), - }, - ), - ( - enums::PaymentMethodType::Swish, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::new(), - } - ), - ]), - }, - ), - ( - enums::PaymentMethodType::TouchNGo, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::new(), - } - ), - ]), - }, - ), - ( - // Added shipping fields for the SDK flow to accept it from wallet directly, - // this won't show up in SDK in payment's sheet but will be used in the background - enums::PaymentMethodType::Paypal, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from([ - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - )] - ), - } - ), - ( - enums::Connector::Braintree, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::new(), - } - ), - ( - enums::Connector::Novalnet, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email_address".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ] - ), - } - ), - ( - enums::Connector::Paypal, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new( - ), - common: HashMap::from( - [ - ( - "shipping.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "shipping.address.first_name".to_string(), - display_name: "shipping_first_name".to_string(), - field_type: enums::FieldType::UserShippingName, - value: None, - } - ), - ( - "shipping.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "shipping.address.last_name".to_string(), - display_name: "shipping_last_name".to_string(), - field_type: enums::FieldType::UserShippingName, - value: None, - } - ), - ( - "shipping.address.city".to_string(), - RequiredFieldInfo { - required_field: "shipping.address.city".to_string(), - display_name: "city".to_string(), - field_type: enums::FieldType::UserShippingAddressCity, - value: None, - } - ), - ( - "shipping.address.state".to_string(), - RequiredFieldInfo { - required_field: "shipping.address.state".to_string(), - display_name: "state".to_string(), - field_type: enums::FieldType::UserShippingAddressState, - value: None, - } - ), - ( - "shipping.address.zip".to_string(), - RequiredFieldInfo { - required_field: "shipping.address.zip".to_string(), - display_name: "zip".to_string(), - field_type: enums::FieldType::UserShippingAddressPincode, - value: None, - } - ), - ( - "shipping.address.country".to_string(), - RequiredFieldInfo { - required_field: "shipping.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserShippingAddressCountry{ - options: vec![ - "ALL".to_string(), - ] - }, - value: None, - } - ), - ( - "shipping.address.line1".to_string(), - RequiredFieldInfo { - required_field: "shipping.address.line1".to_string(), - display_name: "line1".to_string(), - field_type: enums::FieldType::UserShippingAddressLine1, - value: None, - } - ), - ] - ), - } - ), - ]), - }, - ), - ( - enums::PaymentMethodType::Mifinity, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Mifinity, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from([ - ( - "payment_method_data.wallet.mifinity.date_of_birth".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.wallet.mifinity.date_of_birth".to_string(), - display_name: "date_of_birth".to_string(), - field_type: enums::FieldType::UserDateOfBirth, - value: None, - } - ), - ( - "billing.address.line1".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.line1".to_string(), - display_name: "line1".to_string(), - field_type: enums::FieldType::UserAddressLine1, - value: None, - } - ), - ( - "billing.address.city".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.city".to_string(), - display_name: "city".to_string(), - field_type: enums::FieldType::UserAddressCity, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "first_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "last_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.phone.number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.phone.number".to_string(), - display_name: "phone".to_string(), - field_type: enums::FieldType::UserPhoneNumber, - value: None, - } - ), - ( - "billing.phone.country_code".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.phone.country_code".to_string(), - display_name: "dialing_code".to_string(), - field_type: enums::FieldType::UserPhoneNumberCountryCode, - value: None, - } - ), - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "nationality".to_string(), - field_type: enums::FieldType::UserCountry{ - options: vec![ - "BR".to_string(), - "CN".to_string(), - "SG".to_string(), - "MY".to_string(), - "DE".to_string(), - "CH".to_string(), - "DK".to_string(), - "GB".to_string(), - "ES".to_string(), - "AD".to_string(), - "GI".to_string(), - "FI".to_string(), - "FR".to_string(), - "GR".to_string(), - "HR".to_string(), - "IT".to_string(), - "JP".to_string(), - "MX".to_string(), - "AR".to_string(), - "CO".to_string(), - "CL".to_string(), - "PE".to_string(), - "VE".to_string(), - "UY".to_string(), - "PY".to_string(), - "BO".to_string(), - "EC".to_string(), - "GT".to_string(), - "HN".to_string(), - "SV".to_string(), - "NI".to_string(), - "CR".to_string(), - "PA".to_string(), - "DO".to_string(), - "CU".to_string(), - "PR".to_string(), - "NL".to_string(), - "NO".to_string(), - "PL".to_string(), - "PT".to_string(), - "SE".to_string(), - "RU".to_string(), - "TR".to_string(), - "TW".to_string(), - "HK".to_string(), - "MO".to_string(), - "AX".to_string(), - "AL".to_string(), - "DZ".to_string(), - "AS".to_string(), - "AO".to_string(), - "AI".to_string(), - "AG".to_string(), - "AM".to_string(), - "AW".to_string(), - "AU".to_string(), - "AT".to_string(), - "AZ".to_string(), - "BS".to_string(), - "BH".to_string(), - "BD".to_string(), - "BB".to_string(), - "BE".to_string(), - "BZ".to_string(), - "BJ".to_string(), - "BM".to_string(), - "BT".to_string(), - "BQ".to_string(), - "BA".to_string(), - "BW".to_string(), - "IO".to_string(), - "BN".to_string(), - "BG".to_string(), - "BF".to_string(), - "BI".to_string(), - "KH".to_string(), - "CM".to_string(), - "CA".to_string(), - "CV".to_string(), - "KY".to_string(), - "CF".to_string(), - "TD".to_string(), - "CX".to_string(), - "CC".to_string(), - "KM".to_string(), - "CG".to_string(), - "CK".to_string(), - "CI".to_string(), - "CW".to_string(), - "CY".to_string(), - "CZ".to_string(), - "DJ".to_string(), - "DM".to_string(), - "EG".to_string(), - "GQ".to_string(), - "ER".to_string(), - "EE".to_string(), - "ET".to_string(), - "FK".to_string(), - "FO".to_string(), - "FJ".to_string(), - "GF".to_string(), - "PF".to_string(), - "TF".to_string(), - "GA".to_string(), - "GM".to_string(), - "GE".to_string(), - "GH".to_string(), - "GL".to_string(), - "GD".to_string(), - "GP".to_string(), - "GU".to_string(), - "GG".to_string(), - "GN".to_string(), - "GW".to_string(), - "GY".to_string(), - "HT".to_string(), - "HM".to_string(), - "VA".to_string(), - "IS".to_string(), - "IN".to_string(), - "ID".to_string(), - "IE".to_string(), - "IM".to_string(), - "IL".to_string(), - "JE".to_string(), - "JO".to_string(), - "KZ".to_string(), - "KE".to_string(), - "KI".to_string(), - "KW".to_string(), - "KG".to_string(), - "LA".to_string(), - "LV".to_string(), - "LB".to_string(), - "LS".to_string(), - "LI".to_string(), - "LT".to_string(), - "LU".to_string(), - "MK".to_string(), - "MG".to_string(), - "MW".to_string(), - "MV".to_string(), - "ML".to_string(), - "MT".to_string(), - "MH".to_string(), - "MQ".to_string(), - "MR".to_string(), - "MU".to_string(), - "YT".to_string(), - "FM".to_string(), - "MD".to_string(), - "MC".to_string(), - "MN".to_string(), - "ME".to_string(), - "MS".to_string(), - "MA".to_string(), - "MZ".to_string(), - "NA".to_string(), - "NR".to_string(), - "NP".to_string(), - "NC".to_string(), - "NZ".to_string(), - "NE".to_string(), - "NG".to_string(), - "NU".to_string(), - "NF".to_string(), - "MP".to_string(), - "OM".to_string(), - "PK".to_string(), - "PW".to_string(), - "PS".to_string(), - "PG".to_string(), - "PH".to_string(), - "PN".to_string(), - "QA".to_string(), - "RE".to_string(), - "RO".to_string(), - "RW".to_string(), - "BL".to_string(), - "SH".to_string(), - "KN".to_string(), - "LC".to_string(), - "MF".to_string(), - "PM".to_string(), - "VC".to_string(), - "WS".to_string(), - "SM".to_string(), - "ST".to_string(), - "SA".to_string(), - "SN".to_string(), - "RS".to_string(), - "SC".to_string(), - "SL".to_string(), - "SX".to_string(), - "SK".to_string(), - "SI".to_string(), - "SB".to_string(), - "SO".to_string(), - "ZA".to_string(), - "GS".to_string(), - "KR".to_string(), - "LK".to_string(), - "SR".to_string(), - "SJ".to_string(), - "SZ".to_string(), - "TH".to_string(), - "TL".to_string(), - "TG".to_string(), - "TK".to_string(), - "TO".to_string(), - "TT".to_string(), - "TN".to_string(), - "TM".to_string(), - "TC".to_string(), - "TV".to_string(), - "UG".to_string(), - "UA".to_string(), - "AE".to_string(), - "UZ".to_string(), - "VU".to_string(), - "VN".to_string(), - "VG".to_string(), - "VI".to_string(), - "WF".to_string(), - "EH".to_string(), - "ZM".to_string(), - ] - }, - value: None, - } - - ), - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email_address".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "payment_method_data.wallet.mifinity.language_preference".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.wallet.mifinity.language_preference".to_string(), - display_name: "language_preference".to_string(), - field_type: enums::FieldType::LanguagePreference{ - options: vec![ - "BR".to_string(), - "PT_BR".to_string(), - "CN".to_string(), - "ZH_CN".to_string(), - "DE".to_string(), - "DK".to_string(), - "DA".to_string(), - "DA_DK".to_string(), - "EN".to_string(), - "ES".to_string(), - "FI".to_string(), - "FR".to_string(), - "GR".to_string(), - "EL".to_string(), - "EL_GR".to_string(), - "HR".to_string(), - "IT".to_string(), - "JP".to_string(), - "JA".to_string(), - "JA_JP".to_string(), - "LA".to_string(), - "ES_LA".to_string(), - "NL".to_string(), - "NO".to_string(), - "PL".to_string(), - "PT".to_string(), - "RU".to_string(), - "SV".to_string(), - "SE".to_string(), - "SV_SE".to_string(), - "ZH".to_string(), - "TW".to_string(), - "ZH_TW".to_string(), - ] - }, - value: None, - } - ), - ]), - } - ), - ]), - } - ), - ])), - ), - ( - enums::PaymentMethod::PayLater, - PaymentMethodType(HashMap::from([ - ( - enums::PaymentMethodType::AfterpayClearpay, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Stripe, - RequiredFieldFinal { - mandate : HashMap::new(), - non_mandate: HashMap::from([ - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "billing_first_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "billing_last_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ), - ( - "billing.address.line1".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.line1".to_string(), - display_name: "line1".to_string(), - field_type: enums::FieldType::UserAddressLine1, - value: None, - } - ), - ( - "billing.address.city".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.city".to_string(), - display_name: "city".to_string(), - field_type: enums::FieldType::UserAddressCity, - value: None, - } - ), - ( - "billing.address.zip".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.zip".to_string(), - display_name: "zip".to_string(), - field_type: enums::FieldType::UserAddressPincode, - value: None, - } - ), - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserAddressCountry{ - options: vec![ - "GB".to_string(), - "AU".to_string(), - "CA".to_string(), - "US".to_string(), - "NZ".to_string(), - ] - }, - value: None, - } - ), - ( - "billing.address.state".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.state".to_string(), - display_name: "state".to_string(), - field_type: enums::FieldType::UserAddressState, - value: None, - } - ), - ( - "shipping.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "shipping.address.first_name".to_string(), - display_name: "shipping_first_name".to_string(), - field_type: enums::FieldType::UserShippingName, - value: None, - } - ), - ( - "shipping.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "shipping.address.last_name".to_string(), - display_name: "shipping_last_name".to_string(), - field_type: enums::FieldType::UserShippingName, - value: None, - } - ), - ( - "shipping.address.city".to_string(), - RequiredFieldInfo { - required_field: "shipping.address.city".to_string(), - display_name: "city".to_string(), - field_type: enums::FieldType::UserShippingAddressCity, - value: None, - } - ), - ( - "shipping.address.state".to_string(), - RequiredFieldInfo { - required_field: "shipping.address.state".to_string(), - display_name: "state".to_string(), - field_type: enums::FieldType::UserShippingAddressState, - value: None, - } - ), - ( - "shipping.address.zip".to_string(), - RequiredFieldInfo { - required_field: "shipping.address.zip".to_string(), - display_name: "zip".to_string(), - field_type: enums::FieldType::UserShippingAddressPincode, - value: None, - } - ), - ( - "shipping.address.country".to_string(), - RequiredFieldInfo { - required_field: "shipping.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserShippingAddressCountry{ - options: vec![ - "ALL".to_string(), - ] - }, - value: None, - } - ), - ( - "shipping.address.line1".to_string(), - RequiredFieldInfo { - required_field: "shipping.address.line1".to_string(), - display_name: "line1".to_string(), - field_type: enums::FieldType::UserShippingAddressLine1, - value: None, - } - ), - ]), - common : HashMap::new(), - } - ), - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate : HashMap::new(), - non_mandate: HashMap::from([ - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "billing_first_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "billing_last_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ), - ( - "billing.address.line1".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.line1".to_string(), - display_name: "line1".to_string(), - field_type: enums::FieldType::UserAddressLine1, - value: None, - } - ), - ( - "billing.address.line2".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.line2".to_string(), - display_name: "line2".to_string(), - field_type: enums::FieldType::UserAddressLine2, - value: None, - } - ), - ( - "billing.address.city".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.city".to_string(), - display_name: "city".to_string(), - field_type: enums::FieldType::UserAddressCity, - value: None, - } - ), - ( - "billing.address.zip".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.zip".to_string(), - display_name: "zip".to_string(), - field_type: enums::FieldType::UserAddressPincode, - value: None, - } - ), - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserAddressCountry{ - options: vec![ - "GB".to_string(), - "AU".to_string(), - "CA".to_string(), - "US".to_string(), - "NZ".to_string(), - ] - }, - value: None, - } - ), - ( - "billing.address.state".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.state".to_string(), - display_name: "state".to_string(), - field_type: enums::FieldType::UserAddressState, - value: None, - } - ), - ( - "shipping.address.city".to_string(), - RequiredFieldInfo { - required_field: "shipping.address.city".to_string(), - display_name: "city".to_string(), - field_type: enums::FieldType::UserShippingAddressCity, - value: None, - } - ), - ( - "shipping.address.zip".to_string(), - RequiredFieldInfo { - required_field: "shipping.address.zip".to_string(), - display_name: "zip".to_string(), - field_type: enums::FieldType::UserShippingAddressPincode, - value: None, - } - ), - ( - "shipping.address.country".to_string(), - RequiredFieldInfo { - required_field: "shipping.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserShippingAddressCountry{ - options: vec![ - "GB".to_string(), - "AU".to_string(), - "CA".to_string(), - "US".to_string(), - "NZ".to_string(), - ] - }, - value: None, - } - ), - ( - "shipping.address.line1".to_string(), - RequiredFieldInfo { - required_field: "shipping.address.line1".to_string(), - display_name: "line1".to_string(), - field_type: enums::FieldType::UserShippingAddressLine1, - value: None, - } - ), - ( - "shipping.address.line2".to_string(), - RequiredFieldInfo { - required_field: "shipping.address.line2".to_string(), - display_name: "line2".to_string(), - field_type: enums::FieldType::UserShippingAddressLine2, - value: None, - } - ), - ]), - common : HashMap::new(), - } - ) - ]), - }, - ), - ( - enums::PaymentMethodType::Klarna, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Stripe, - RequiredFieldFinal { - mandate : HashMap::new(), - non_mandate: HashMap::from([ - ( "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "billing_country".to_string(), - field_type: enums::FieldType::UserAddressCountry{ - options: vec![ - "AU".to_string(), - "AT".to_string(), - "BE".to_string(), - "CA".to_string(), - "CZ".to_string(), - "DK".to_string(), - "FI".to_string(), - "FR".to_string(), - "GR".to_string(), - "DE".to_string(), - "IE".to_string(), - "IT".to_string(), - "NL".to_string(), - "NZ".to_string(), - "NO".to_string(), - "PL".to_string(), - "PT".to_string(), - "RO".to_string(), - "ES".to_string(), - "SE".to_string(), - "CH".to_string(), - "GB".to_string(), - "US".to_string(), - ] - }, - value: None, - }), - ("billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - }) - ]), - common : HashMap::new(), - } - ), - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate : HashMap::new(), - non_mandate: HashMap::new(), - common : HashMap::from([ - ( "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "billing_country".to_string(), - field_type: enums::FieldType::UserAddressCountry{ - options: vec![ - "ALL".to_string(), - ] - }, - value: None, - }), - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ]), - } - ), - ( - enums::Connector::Klarna, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from([ - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserAddressCountry{ - options: vec![ - "AU".to_string(), - "AT".to_string(), - "BE".to_string(), - "CA".to_string(), - "CZ".to_string(), - "DK".to_string(), - "FI".to_string(), - "FR".to_string(), - "DE".to_string(), - "GR".to_string(), - "IE".to_string(), - "IT".to_string(), - "NL".to_string(), - "NZ".to_string(), - "NO".to_string(), - "PL".to_string(), - "PT".to_string(), - "ES".to_string(), - "SE".to_string(), - "CH".to_string(), - "GB".to_string(), - "US".to_string(), - ] - }, - value: None, - } - ) - ]), - } - ) - ]), - }, - ), - ( - enums::PaymentMethodType::Affirm, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Stripe, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::new(), - } - ), - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from( - [ - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.city".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.city".to_string(), - display_name: "city".to_string(), - field_type: enums::FieldType::UserAddressCity, - value: None, - } - ), - ( - "billing.address.state".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.state".to_string(), - display_name: "state".to_string(), - field_type: enums::FieldType::UserAddressState, - value: None, - } - ), - ( - "billing.address.zip".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.zip".to_string(), - display_name: "zip".to_string(), - field_type: enums::FieldType::UserAddressPincode, - value: None, - } - ), - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserAddressCountry{ - options: vec![ - "US".to_string(), - ] - }, - value: None, - } - ), - ( - "billing.phone.number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.phone.number".to_string(), - display_name: "phone_number".to_string(), - field_type: enums::FieldType::UserPhoneNumber, - value: None, - } - ), - ( - "billing.phone.country_code".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.phone.country_code".to_string(), - display_name: "dialing_code".to_string(), - field_type: enums::FieldType::UserPhoneNumberCountryCode, - value: None, - } - ), - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "billing.address.line1".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.line1".to_string(), - display_name: "line1".to_string(), - field_type: enums::FieldType::UserAddressLine1, - value: None, - } - ), - ( - "billing.address.line2".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.line2".to_string(), - display_name: "line2".to_string(), - field_type: enums::FieldType::UserAddressLine2, - value: None, - } - ), - ( - "shipping.address.line1".to_string(), - RequiredFieldInfo { - required_field: "shipping.address.line1".to_string(), - display_name: "line1".to_string(), - field_type: enums::FieldType::UserAddressLine1, - value: None, - } - ), - ( - "shipping.address.line2".to_string(), - RequiredFieldInfo { - required_field: "shipping.address.line2".to_string(), - display_name: "line2".to_string(), - field_type: enums::FieldType::UserAddressLine2, - value: None, - } - ), - ( - "shipping.address.zip".to_string(), - RequiredFieldInfo { - required_field: "shipping.address.zip".to_string(), - display_name: "zip".to_string(), - field_type: enums::FieldType::UserShippingAddressPincode, - value: None, - } - ), - ( - "shipping.address.city".to_string(), - RequiredFieldInfo { - required_field: "shipping.address.city".to_string(), - display_name: "city".to_string(), - field_type: enums::FieldType::UserShippingAddressCity, - value: None, - } - ), - ( - "shipping.address.country".to_string(), - RequiredFieldInfo { - required_field: "shipping.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserCountry { - options: vec![ - "US".to_string(), - ]}, - value: None, - } - ), - - ] - ), - common: HashMap::new(), - } - ), - ]), - }, - ), - ( - enums::PaymentMethodType::PayBright, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from( - [ - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.city".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.city".to_string(), - display_name: "city".to_string(), - field_type: enums::FieldType::UserAddressCity, - value: None, - } - ), - ( - "billing.address.state".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.state".to_string(), - display_name: "state".to_string(), - field_type: enums::FieldType::UserAddressState, - value: None, - } - ), - ( - "billing.address.zip".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.zip".to_string(), - display_name: "zip".to_string(), - field_type: enums::FieldType::UserAddressPincode, - value: None, - } - ), - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserAddressCountry{ - options: vec![ - "CA".to_string(), - ] - }, - value: None, - } - ), - ( - "billing.phone.number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.phone.number".to_string(), - display_name: "phone_number".to_string(), - field_type: enums::FieldType::UserPhoneNumber, - value: None, - } - ), - ( - "billing.phone.country_code".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.phone.country_code".to_string(), - display_name: "dialing_code".to_string(), - field_type: enums::FieldType::UserPhoneNumberCountryCode, - value: None, - } - ), - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "billing.address.line1".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.line1".to_string(), - display_name: "line1".to_string(), - field_type: enums::FieldType::UserAddressLine1, - value: None, - } - ), - ( - "billing.address.line2".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.line2".to_string(), - display_name: "line2".to_string(), - field_type: enums::FieldType::UserAddressLine2, - value: None, - } - ), - ( - "shipping.address.city".to_string(), - RequiredFieldInfo { - required_field: "shipping.address.city".to_string(), - display_name: "city".to_string(), - field_type: enums::FieldType::UserShippingAddressCity, - value: None, - } - ), - ( - "shipping.address.zip".to_string(), - RequiredFieldInfo { - required_field: "shipping.address.zip".to_string(), - display_name: "zip".to_string(), - field_type: enums::FieldType::UserShippingAddressPincode, - value: None, - } - ), - ( - "shipping.address.country".to_string(), - RequiredFieldInfo { - required_field: "shipping.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserShippingAddressCountry{ - options: vec![ - "ALL".to_string(), - ] - }, - value: None, - } - ), - ( - "shipping.address.line1".to_string(), - RequiredFieldInfo { - required_field: "shipping.address.line1".to_string(), - display_name: "line1".to_string(), - field_type: enums::FieldType::UserShippingAddressLine1, - value: None, - } - ), - ( - "shipping.address.line2".to_string(), - RequiredFieldInfo { - required_field: "shipping.address.line2".to_string(), - display_name: "line2".to_string(), - field_type: enums::FieldType::UserShippingAddressLine2, - value: None, - } - ), - ] - ), - common: HashMap::new(), - } - ), - ]), - }, - ), - ( - enums::PaymentMethodType::Walley, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from( - [ - ( - "billing.phone.number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.phone.number".to_string(), - display_name: "phone".to_string(), - field_type: enums::FieldType::UserPhoneNumber, - value: None, - } - ), - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserAddressCountry{ - options: vec![ - "DK".to_string(), - "FI".to_string(), - "NO".to_string(), - "SE".to_string(), - ]}, - value: None, - } - ), - ( - "billing.phone.country_code".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.phone.country_code".to_string(), - display_name: "dialing_code".to_string(), - field_type: enums::FieldType::UserPhoneNumberCountryCode, - value: None, - } - ), - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ] - ), - common: HashMap::new(), - } - ), - ]), - }, - ), - ( - enums::PaymentMethodType::Alma, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from( - [ - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.city".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.city".to_string(), - display_name: "city".to_string(), - field_type: enums::FieldType::UserAddressCity, - value: None, - } - ), - ( - "billing.address.state".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.state".to_string(), - display_name: "state".to_string(), - field_type: enums::FieldType::UserAddressState, - value: None, - } - ), - ( - "billing.address.zip".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.zip".to_string(), - display_name: "zip".to_string(), - field_type: enums::FieldType::UserAddressPincode, - value: None, - } - ), - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserAddressCountry{ - options: vec![ - "FR".to_string(), - ] - }, - value: None, - } - ), - ( - "billing.phone.number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.phone.number".to_string(), - display_name: "phone_number".to_string(), - field_type: enums::FieldType::UserPhoneNumber, - value: None, - } - ), - ( - "billing.phone.country_code".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.phone.country_code".to_string(), - display_name: "dialing_code".to_string(), - field_type: enums::FieldType::UserPhoneNumberCountryCode, - value: None, - } - ), - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "billing.address.line1".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.line1".to_string(), - display_name: "line1".to_string(), - field_type: enums::FieldType::UserAddressLine1, - value: None, - } - ), - ( - "billing.address.line2".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.line2".to_string(), - display_name: "line2".to_string(), - field_type: enums::FieldType::UserAddressLine2, - value: None, - } - ) - ] - ), - common: HashMap::new(), - } - ), - ]), - }, - ), - ( - enums::PaymentMethodType::Atome, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from( - [ - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.city".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.city".to_string(), - display_name: "city".to_string(), - field_type: enums::FieldType::UserAddressCity, - value: None, - } - ), - ( - "billing.address.state".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.state".to_string(), - display_name: "state".to_string(), - field_type: enums::FieldType::UserAddressState, - value: None, - } - ), - ( - "billing.address.zip".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.zip".to_string(), - display_name: "zip".to_string(), - field_type: enums::FieldType::UserAddressPincode, - value: None, - } - ), - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserAddressCountry{ - options: vec![ - "MY".to_string(), - "SG".to_string() - ] - }, - value: None, - } - ), - ( - "billing.phone.number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.phone.number".to_string(), - display_name: "phone_number".to_string(), - field_type: enums::FieldType::UserPhoneNumber, - value: None, - } - ), - ( - "billing.phone.country_code".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.phone.country_code".to_string(), - display_name: "dialing_code".to_string(), - field_type: enums::FieldType::UserPhoneNumberCountryCode, - value: None, - } - ), - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "billing.address.line1".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.line1".to_string(), - display_name: "line1".to_string(), - field_type: enums::FieldType::UserAddressLine1, - value: None, - } - ), - ( - "billing.address.line2".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.line2".to_string(), - display_name: "line2".to_string(), - field_type: enums::FieldType::UserAddressLine2, - value: None, - } - ) - ] - ), - common: HashMap::new(), - } - ), - ]), - }, - ), - ])), - ), - ( - enums::PaymentMethod::Crypto, - PaymentMethodType(HashMap::from([ - ( - enums::PaymentMethodType::CryptoCurrency, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Cryptopay, - RequiredFieldFinal { - mandate : HashMap::new(), - non_mandate: HashMap::from([ - ( - "payment_method_data.crypto.pay_currency".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.crypto.pay_currency".to_string(), - display_name: "currency".to_string(), - field_type: enums::FieldType::UserCurrency{ - options: vec![ - "BTC".to_string(), - "LTC".to_string(), - "ETH".to_string(), - "XRP".to_string(), - "XLM".to_string(), - "BCH".to_string(), - "ADA".to_string(), - "SOL".to_string(), - "SHIB".to_string(), - "TRX".to_string(), - "DOGE".to_string(), - "BNB".to_string(), - "USDT".to_string(), - "USDC".to_string(), - "DAI".to_string(), - ] - }, - value: None, - } - ), - ( - "payment_method_data.crypto.network".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.crypto.network".to_string(), - display_name: "network".to_string(), - field_type: enums::FieldType::UserCryptoCurrencyNetwork, - value: None, - } - ), - ]), - common : HashMap::new(), - } - ), - ]), - }, - ), - ])), - ), - ( - enums::PaymentMethod::Voucher, - PaymentMethodType(HashMap::from([ - ( - enums::PaymentMethodType::Boleto, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate : HashMap::new(), - non_mandate : HashMap::from([ - ( - "payment_method_data.voucher.boleto.social_security_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.voucher.boleto.social_security_number".to_string(), - display_name: "social_security_number".to_string(), - field_type: enums::FieldType::UserSocialSecurityNumber, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.city".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.city".to_string(), - display_name: "city".to_string(), - field_type: enums::FieldType::UserAddressCity, - value: None, - } - ), - ( - "billing.address.state".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.state".to_string(), - display_name: "state".to_string(), - field_type: enums::FieldType::UserAddressState, - value: None, - } - ), - ( - "billing.address.zip".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.zip".to_string(), - display_name: "zip".to_string(), - field_type: enums::FieldType::UserAddressPincode, - value: None, - } - ), - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserAddressCountry{ - options: vec![ - "BR".to_string(), - ] - }, - value: None, - } - ), - ( - "billing.address.line1".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.line1".to_string(), - display_name: "line1".to_string(), - field_type: enums::FieldType::UserAddressLine1, - value: None, - } - ), - ( - "billing.address.line2".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.line2".to_string(), - display_name: "line2".to_string(), - field_type: enums::FieldType::UserAddressLine2, - value: None, - } - ), - ]), - common : HashMap::new(), - } - ), - ( - enums::Connector::Zen, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::new(), - } - ) - ]), - }, - ), - ( - enums::PaymentMethodType::Alfamart, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate : HashMap::new(), - non_mandate : HashMap::from([ - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ) - ]), - common : HashMap::new(), - } - ) - ]), - }, - ), - ( - enums::PaymentMethodType::Indomaret, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate : HashMap::new(), - non_mandate : HashMap::from([ - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ) - ]), - common : HashMap::new(), - } - ) - ]), - }, - ), - ( - enums::PaymentMethodType::Oxxo, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate : HashMap::new(), - non_mandate : HashMap::new(), - common : HashMap::new(), - } - ) - ]), - }, - ), - ( - enums::PaymentMethodType::SevenEleven, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate : HashMap::new(), - non_mandate : HashMap::from([ - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "billing.phone.number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.phone.number".to_string(), - display_name: "phone".to_string(), - field_type: enums::FieldType::UserPhoneNumber, - value: None, - } - ), - ( - "billing.phone.country_code".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.phone.country_code".to_string(), - display_name: "dialing_code".to_string(), - field_type: enums::FieldType::UserPhoneNumberCountryCode, - value: None, - } - ) - ] - ), - common : HashMap::new(), - } - ) - ]), - }, - ), - ( - enums::PaymentMethodType::Lawson, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate : HashMap::new(), - non_mandate : HashMap::from([ - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "billing.phone.number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.phone.number".to_string(), - display_name: "phone".to_string(), - field_type: enums::FieldType::UserPhoneNumber, - value: None, - } - ), - ( - "billing.phone.country_code".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.phone.country_code".to_string(), - display_name: "dialing_code".to_string(), - field_type: enums::FieldType::UserPhoneNumberCountryCode, - value: None, - } - ), - ] - ), - common : HashMap::new(), - } - ) - ]), - }, - ), - ( - enums::PaymentMethodType::MiniStop, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate : HashMap::new(), - non_mandate : HashMap::from([ - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "billing.phone.number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.phone.number".to_string(), - display_name: "phone".to_string(), - field_type: enums::FieldType::UserPhoneNumber, - value: None, - } - ), - ( - "billing.phone.country_code".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.phone.country_code".to_string(), - display_name: "dialing_code".to_string(), - field_type: enums::FieldType::UserPhoneNumberCountryCode, - value: None, - } - ), - ] - ), - common : HashMap::new(), - } - ) - ]), - }, - ), - ( - enums::PaymentMethodType::FamilyMart, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate : HashMap::new(), - non_mandate : HashMap::from([ - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "billing.phone.number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.phone.number".to_string(), - display_name: "phone".to_string(), - field_type: enums::FieldType::UserPhoneNumber, - value: None, - } - ), - ( - "billing.phone.country_code".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.phone.country_code".to_string(), - display_name: "dialing_code".to_string(), - field_type: enums::FieldType::UserPhoneNumberCountryCode, - value: None, - } - ), - ] - ), - common : HashMap::new(), - } - ) - ]), - }, - ), - ( - enums::PaymentMethodType::Seicomart, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate : HashMap::new(), - non_mandate : HashMap::from([ - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "billing.phone.number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.phone.number".to_string(), - display_name: "phone".to_string(), - field_type: enums::FieldType::UserPhoneNumber, - value: None, - } - ), - ( - "billing.phone.country_code".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.phone.country_code".to_string(), - display_name: "dialing_code".to_string(), - field_type: enums::FieldType::UserPhoneNumberCountryCode, - value: None, - } - ), - ] - ), - common : HashMap::new(), - } - ) - ]), - }, - ), - ( - enums::PaymentMethodType::PayEasy, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate : HashMap::new(), - non_mandate : HashMap::from([ - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "billing.phone.number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.phone.number".to_string(), - display_name: "phone".to_string(), - field_type: enums::FieldType::UserPhoneNumber, - value: None, - } - ), - ( - "billing.phone.country_code".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.phone.country_code".to_string(), - display_name: "dialing_code".to_string(), - field_type: enums::FieldType::UserPhoneNumberCountryCode, - value: None, - } - ), - ] - ), - common : HashMap::new(), - } - ) - ]), - }, - ), - ])), - ), - ( - enums::PaymentMethod::Upi, - PaymentMethodType(HashMap::from([ - ( - enums::PaymentMethodType::UpiCollect, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Razorpay, - RequiredFieldFinal { - mandate : HashMap::new(), - non_mandate : HashMap::new(), - common : HashMap::from([ - ( - "payment_method_data.upi.upi_collect.vpa_id".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.upi.upi_collect.vpa_id".to_string(), - display_name: "vpa_id".to_string(), - field_type: enums::FieldType::UserVpaId, - value: None, - } - ), - ]), - } - ), - ]), - }, - ), - ])), - ), - ( - enums::PaymentMethod::BankDebit, - PaymentMethodType(HashMap::from([( - enums::PaymentMethodType::Ach, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Stripe, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from([( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "billing_first_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "owner_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ), - ( - "payment_method_data.bank_debit.ach_bank_debit.account_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.bank_debit.ach_bank_debit.account_number".to_string(), - display_name: "bank_account_number".to_string(), - field_type: enums::FieldType::UserBankAccountNumber, - value: None, - } - ), - ( - "payment_method_data.bank_debit.ach_bank_debit.routing_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.bank_debit.ach_bank_debit.routing_number".to_string(), - display_name: "bank_routing_number".to_string(), - field_type: enums::FieldType::UserBankRoutingNumber, - value: None, - } - ) - ]), - }), - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from([ ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "owner_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - }), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "owner_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ), - ( - "payment_method_data.bank_debit.ach_bank_debit.account_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.bank_debit.ach_bank_debit.account_number".to_string(), - display_name: "bank_account_number".to_string(), - field_type: enums::FieldType::UserBankAccountNumber, - value: None, - } - ), - ( - "payment_method_data.bank_debit.ach_bank_debit.routing_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.bank_debit.ach_bank_debit.routing_number".to_string(), - display_name: "bank_routing_number".to_string(), - field_type: enums::FieldType::UserBankRoutingNumber, - value: None, - } - ) - ]), - }) - ] - )} - ), - ( - enums::PaymentMethodType::Sepa, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Stripe, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from([ ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "billing_first_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "owner_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ), - ( - "payment_method_data.bank_debit.sepa_bank_debit.iban".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.bank_debit.sepa_bank_debit.iban".to_string(), - display_name: "iban".to_string(), - field_type: enums::FieldType::UserIban, - value: None, - } - ), - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ) - ]), - } - ), - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from([ ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "owner_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - }), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "owner_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ), - ( - "payment_method_data.bank_debit.sepa_bank_debit.iban".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.bank_debit.sepa_bank_debit.iban".to_string(), - display_name: "iban".to_string(), - field_type: enums::FieldType::UserIban, - value: None, - } - ) - ]), - } - ), - ( - enums::Connector::Deutschebank, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from([ ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "owner_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - }), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "owner_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ), - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "payment_method_data.bank_debit.sepa_bank_debit.iban".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.bank_debit.sepa_bank_debit.iban".to_string(), - display_name: "iban".to_string(), - field_type: enums::FieldType::UserIban, - value: None, - } - ) - ]), - } - ), - ( - enums::Connector::Inespay, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from([ - ( - "payment_method_data.bank_debit.sepa_bank_debit.iban".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.bank_debit.sepa_bank_debit.iban".to_string(), - display_name: "iban".to_string(), - field_type: enums::FieldType::UserIban, - value: None, - } - ) - ]), - } - ) - ]), - }, - ), - ( - enums::PaymentMethodType::Bacs, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Stripe, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from([ ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "billing_first_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ), - ( - "payment_method_data.bank_debit.bacs_bank_debit.account_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.bank_debit.bacs_bank_debit.account_number".to_string(), - display_name: "bank_account_number".to_string(), - field_type: enums::FieldType::UserBankAccountNumber, - value: None, - } - ), - ( - "payment_method_data.bank_debit.bacs_bank_debit.sort_code".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.bank_debit.bacs_bank_debit.sort_code".to_string(), - display_name: "bank_sort_code".to_string(), - field_type: enums::FieldType::UserBankSortCode, - value: None, - } - ), - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserAddressCountry { - options: vec!["UK".to_string()], - }, - value: None, - }, - ), - ( - "billing.address.zip".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.zip".to_string(), - display_name: "zip".to_string(), - field_type: enums::FieldType::UserAddressPincode, - value: None, - }, - ), - ( - "billing.address.line1".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.line1".to_string(), - display_name: "line1".to_string(), - field_type: enums::FieldType::UserAddressLine1, - value: None, - }, - ) - ]), - } - ), - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from([ ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "owner_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - }), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "owner_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ), - ( - "payment_method_data.bank_debit.bacs_bank_debit.account_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.bank_debit.bacs_bank_debit.account_number".to_string(), - display_name: "bank_account_number".to_string(), - field_type: enums::FieldType::UserBankAccountNumber, - value: None, - } - ), - ( - "payment_method_data.bank_debit.bacs_bank_debit.sort_code".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.bank_debit.bacs_bank_debit.sort_code".to_string(), - display_name: "bank_sort_code".to_string(), - field_type: enums::FieldType::UserBankSortCode, - value: None, - } - ) - ]), - }) - ]), - }, - ), - ( - enums::PaymentMethodType::Becs, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Stripe, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from([ ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "billing_first_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "owner_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ), - ( - "payment_method_data.bank_debit.becs_bank_debit.account_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.bank_debit.becs_bank_debit.account_number".to_string(), - display_name: "bank_account_number".to_string(), - field_type: enums::FieldType::UserBankAccountNumber, - value: None, - } - ), - ( - "payment_method_data.bank_debit.becs_bank_debit.bsb_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.bank_debit.becs_bank_debit.bsb_number".to_string(), - display_name: "bsb_number".to_string(), - field_type: enums::FieldType::UserBsbNumber, - value: None, - } - ), - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ) - ]), - } - ), - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from([ ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "owner_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - }), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "owner_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ), - ( - "payment_method_data.bank_debit.becs_bank_debit.account_number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.bank_debit.becs_bank_debit.account_number".to_string(), - display_name: "bank_account_number".to_string(), - field_type: enums::FieldType::UserBankAccountNumber, - value: None, - } - ), - ( - "payment_method_data.bank_debit.becs_bank_debit.sort_code".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.bank_debit.becs_bank_debit.sort_code".to_string(), - display_name: "bank_sort_code".to_string(), - field_type: enums::FieldType::UserBankSortCode, - value: None, - } - ) - ]), - }) - ]), - }, - ), - ]))), - ( - enums::PaymentMethod::BankTransfer, - PaymentMethodType(HashMap::from([( - enums::PaymentMethodType::Multibanco, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Stripe, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from([ - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ) - ]), - common: HashMap::new(), - } - ), - ])}), - (enums::PaymentMethodType::LocalBankTransfer, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Zsl, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from([ ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserAddressCountry{ - options: vec![ - "CN".to_string(), - ] - }, - value: None, - } - ), - ( - "billing.address.city".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.city".to_string(), - display_name: "city".to_string(), - field_type: enums::FieldType::UserAddressCity, - value: None, - }, - ), - ]), - common: HashMap::new(), - } - ), - ])}), - (enums::PaymentMethodType::Ach, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Stripe, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from([ - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ) - ]) - } - ), - ])}), - (enums::PaymentMethodType::Pix, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Itaubank, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "payment_method_data.bank_transfer.pix.pix_key".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.bank_transfer.pix.pix_key".to_string(), - display_name: "pix_key".to_string(), - field_type: enums::FieldType::UserPixKey, - value: None, - } - ), - ( - "payment_method_data.bank_transfer.pix.cnpj".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.bank_transfer.pix.cnpj".to_string(), - display_name: "cnpj".to_string(), - field_type: enums::FieldType::UserCnpj, - value: None, - } - ), - ( - "payment_method_data.bank_transfer.pix.cpf".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.bank_transfer.pix.cpf".to_string(), - display_name: "cpf".to_string(), - field_type: enums::FieldType::UserCpf, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ] - ), - } - ), - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::new(), - } - ), - ])}), - ( - enums::PaymentMethodType::PermataBankTransfer, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate : HashMap::new(), - non_mandate : HashMap::from([ - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ) - ]), - common : HashMap::new(), - } - ) - ]), - }, - ), - ( - enums::PaymentMethodType::BcaBankTransfer, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate : HashMap::new(), - non_mandate : HashMap::from([ - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ) - ]), - common : HashMap::new(), - } - ) - ]), - }, - ), - ( - enums::PaymentMethodType::BniVa, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate : HashMap::new(), - non_mandate : HashMap::from([ - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ) - ]), - common : HashMap::new(), - } - ) - ]), - }, - ), - ( - enums::PaymentMethodType::BriVa, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate : HashMap::new(), - non_mandate : HashMap::from([ - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ) - ]), - common : HashMap::new(), - } - ) - ]), - }, - ), - ( - enums::PaymentMethodType::CimbVa, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate : HashMap::new(), - non_mandate : HashMap::from([ - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ) - ]), - common : HashMap::new(), - } - ) - ]), - }, - ), - ( - enums::PaymentMethodType::DanamonVa, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate : HashMap::new(), - non_mandate : HashMap::from([ - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ) - ]), - common : HashMap::new(), - } - ) - ]), - }, - ), - ( - enums::PaymentMethodType::MandiriVa, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate : HashMap::new(), - non_mandate : HashMap::from([ - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ) - ]), - common : HashMap::new(), - } - ) - ]), - }, - ), - ( - enums::PaymentMethodType::SepaBankTransfer, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Stripe, - RequiredFieldFinal { - mandate : HashMap::new(), - non_mandate : HashMap::new(), - common : HashMap::from([ - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserAddressCountry { - options: vec![ - "BE".to_string(), - "DE".to_string(), - "ES".to_string(), - "FR".to_string(), - "IE".to_string(), - "NL".to_string(), - ], - }, - value: None, - }, - ), - ]), - } - ), - ( - enums::Connector::Trustpay, - RequiredFieldFinal { - mandate : HashMap::new(), - non_mandate : HashMap::new(), - common : HashMap::from([ - ( - "email".to_string(), - RequiredFieldInfo { - required_field: "email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "billing_first_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "billing_last_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ), - ( - "billing.address.line1".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.line1".to_string(), - display_name: "line1".to_string(), - field_type: enums::FieldType::UserAddressLine1, - value: None, - } - ), - ( - "billing.address.city".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.city".to_string(), - display_name: "city".to_string(), - field_type: enums::FieldType::UserAddressCity, - value: None, - } - ), - ( - "billing.address.zip".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.zip".to_string(), - display_name: "zip".to_string(), - field_type: enums::FieldType::UserAddressPincode, - value: None, - } - ), - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserAddressCountry{ - options: vec![ - "ALL".to_string(), - ] - }, - value: None, - } - ), - ]), - } - ) - ]), - }, - ), - ( - enums::PaymentMethodType::InstantBankTransfer, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Trustpay, - RequiredFieldFinal { - mandate : HashMap::new(), - non_mandate : HashMap::new(), - common : HashMap::from([ - ( - "email".to_string(), - RequiredFieldInfo { - required_field: "email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "billing_first_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "billing_last_name".to_string(), - field_type: enums::FieldType::UserBillingName, - value: None, - } - ), - ( - "billing.address.line1".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.line1".to_string(), - display_name: "line1".to_string(), - field_type: enums::FieldType::UserAddressLine1, - value: None, - } - ), - ( - "billing.address.city".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.city".to_string(), - display_name: "city".to_string(), - field_type: enums::FieldType::UserAddressCity, - value: None, - } - ), - ( - "billing.address.zip".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.zip".to_string(), - display_name: "zip".to_string(), - field_type: enums::FieldType::UserAddressPincode, - value: None, - } - ), - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserAddressCountry{ - options: vec![ - "ALL".to_string(), - ] - }, - value: None, - } - ), - ]), - } - ) - ]) - } - ), - ( - enums::PaymentMethodType::Bacs, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Stripe, - RequiredFieldFinal { - mandate : HashMap::new(), - non_mandate : HashMap::new(), - common : HashMap::from([ - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ), - ( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "card_holder_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ) - ]), - } - ) - ]), - }, - ), - ]))), - ( - enums::PaymentMethod::GiftCard, - PaymentMethodType(HashMap::from([ - ( - enums::PaymentMethodType::PaySafeCard, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::new(), - } - ), - ]), - }, - ), - ( - enums::PaymentMethodType::Givex, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from([ - - ( - "payment_method_data.gift_card.number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.gift_card.givex.number".to_string(), - display_name: "gift_card_number".to_string(), - field_type: enums::FieldType::UserCardNumber, - value: None, - } - ), - ( - "payment_method_data.gift_card.cvc".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.gift_card.givex.cvc".to_string(), - display_name: "gift_card_cvc".to_string(), - field_type: enums::FieldType::UserCardCvc, - value: None, - } - ), - ]), - common: HashMap::new(), - } - ), - ]), - }, - ), - ])) - ), - ( - enums::PaymentMethod::CardRedirect, - PaymentMethodType(HashMap::from([ - ( - enums::PaymentMethodType::Benefit, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from( - [( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "first_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "last_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.phone.number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.phone.number".to_string(), - display_name: "phone".to_string(), - field_type: enums::FieldType::UserPhoneNumber, - value: None, - } - ), - ( - "billing.phone.country_code".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.phone.country_code".to_string(), - display_name: "dialing_code".to_string(), - field_type: enums::FieldType::UserPhoneNumberCountryCode, - value: None, - } - ), - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ) - ] - ), - common: HashMap::new(), - } - ), - ]), - }, - ), - ( - enums::PaymentMethodType::Knet, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::from( - [( - "billing.address.first_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.first_name".to_string(), - display_name: "first_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.address.last_name".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.last_name".to_string(), - display_name: "last_name".to_string(), - field_type: enums::FieldType::UserFullName, - value: None, - } - ), - ( - "billing.phone.number".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.phone.number".to_string(), - display_name: "phone".to_string(), - field_type: enums::FieldType::UserPhoneNumber, - value: None, - } - ), - ( - "billing.phone.country_code".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.phone.country_code".to_string(), - display_name: "dialing_code".to_string(), - field_type: enums::FieldType::UserPhoneNumberCountryCode, - value: None, - } - ), - ( - "billing.email".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.email".to_string(), - display_name: "email".to_string(), - field_type: enums::FieldType::UserEmailAddress, - value: None, - } - ) - ] - ), - common: HashMap::new(), - } - ), - ]), - }, - ), - ( - enums::PaymentMethodType::MomoAtm, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Adyen, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::new(), - } - ), - ]), - }, - ) - ])) - ), - ( - enums::PaymentMethod::MobilePayment, - PaymentMethodType(HashMap::from([ - ( - enums::PaymentMethodType::DirectCarrierBilling, - ConnectorFields { - fields: HashMap::from([ - ( - enums::Connector::Digitalvirgo, - RequiredFieldFinal { - mandate: HashMap::new(), - non_mandate: HashMap::new(), - common: HashMap::from( - [ - ( - "payment_method_data.mobile_payment.direct_carrier_billing.msisdn".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.mobile_payment.direct_carrier_billing.msisdn".to_string(), - display_name: "mobile_number".to_string(), - field_type: enums::FieldType::UserMsisdn, - value: None, - } - ), - ( - "payment_method_data.mobile_payment.direct_carrier_billing.client_uid".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.mobile_payment.direct_carrier_billing.client_uid".to_string(), - display_name: "client_identifier".to_string(), - field_type: enums::FieldType::UserClientIdentifier, - value: None, - } - ), - ( - "order_details.0.product_name".to_string(), - RequiredFieldInfo { - required_field: "order_details.0.product_name".to_string(), - display_name: "product_name".to_string(), - field_type: enums::FieldType::OrderDetailsProductName, - value: None, - } - ), - ] - ), - } - ), - ]) - } - ) - ])) - ) - ])) - } -} - -pub fn get_worldpay_billing_required_fields() -> HashMap { - HashMap::from([ - ( - "billing.address.line1".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.line1".to_string(), - display_name: "line1".to_string(), - field_type: enums::FieldType::UserAddressLine1, - value: None, - }, - ), - ( - "billing.address.country".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.country".to_string(), - display_name: "country".to_string(), - field_type: enums::FieldType::UserAddressCountry { - options: vec![ - "AF".to_string(), - "AU".to_string(), - "AW".to_string(), - "AZ".to_string(), - "BS".to_string(), - "BH".to_string(), - "BD".to_string(), - "BB".to_string(), - "BZ".to_string(), - "BM".to_string(), - "BT".to_string(), - "BO".to_string(), - "BA".to_string(), - "BW".to_string(), - "BR".to_string(), - "BN".to_string(), - "BG".to_string(), - "BI".to_string(), - "KH".to_string(), - "CA".to_string(), - "CV".to_string(), - "KY".to_string(), - "CL".to_string(), - "CO".to_string(), - "KM".to_string(), - "CD".to_string(), - "CR".to_string(), - "CZ".to_string(), - "DZ".to_string(), - "DK".to_string(), - "DJ".to_string(), - "ST".to_string(), - "DO".to_string(), - "EC".to_string(), - "EG".to_string(), - "SV".to_string(), - "ER".to_string(), - "ET".to_string(), - "FK".to_string(), - "FJ".to_string(), - "GM".to_string(), - "GE".to_string(), - "GH".to_string(), - "GI".to_string(), - "GT".to_string(), - "GN".to_string(), - "GY".to_string(), - "HT".to_string(), - "HN".to_string(), - "HK".to_string(), - "HU".to_string(), - "IS".to_string(), - "IN".to_string(), - "ID".to_string(), - "IR".to_string(), - "IQ".to_string(), - "IE".to_string(), - "IL".to_string(), - "IT".to_string(), - "JM".to_string(), - "JP".to_string(), - "JO".to_string(), - "KZ".to_string(), - "KE".to_string(), - "KW".to_string(), - "LA".to_string(), - "LB".to_string(), - "LS".to_string(), - "LR".to_string(), - "LY".to_string(), - "LT".to_string(), - "MO".to_string(), - "MK".to_string(), - "MG".to_string(), - "MW".to_string(), - "MY".to_string(), - "MV".to_string(), - "MR".to_string(), - "MU".to_string(), - "MX".to_string(), - "MD".to_string(), - "MN".to_string(), - "MA".to_string(), - "MZ".to_string(), - "MM".to_string(), - "NA".to_string(), - "NZ".to_string(), - "NI".to_string(), - "NG".to_string(), - "KP".to_string(), - "NO".to_string(), - "AR".to_string(), - "PK".to_string(), - "PG".to_string(), - "PY".to_string(), - "PE".to_string(), - "UY".to_string(), - "PH".to_string(), - "PL".to_string(), - "GB".to_string(), - "QA".to_string(), - "OM".to_string(), - "RO".to_string(), - "RU".to_string(), - "RW".to_string(), - "WS".to_string(), - "SG".to_string(), - "ST".to_string(), - "ZA".to_string(), - "KR".to_string(), - "LK".to_string(), - "SH".to_string(), - "SD".to_string(), - "SR".to_string(), - "SZ".to_string(), - "SE".to_string(), - "CH".to_string(), - "SY".to_string(), - "TW".to_string(), - "TJ".to_string(), - "TZ".to_string(), - "TH".to_string(), - "TT".to_string(), - "TN".to_string(), - "TR".to_string(), - "UG".to_string(), - "UA".to_string(), - "US".to_string(), - "UZ".to_string(), - "VU".to_string(), - "VE".to_string(), - "VN".to_string(), - "ZM".to_string(), - "ZW".to_string(), - ], - }, - value: None, - }, - ), - ( - "billing.address.city".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.city".to_string(), - display_name: "city".to_string(), - field_type: enums::FieldType::UserAddressCity, - value: None, - }, - ), - ( - "billing.address.zip".to_string(), - RequiredFieldInfo { - required_field: "payment_method_data.billing.address.zip".to_string(), - display_name: "zip".to_string(), - field_type: enums::FieldType::UserAddressPincode, - value: None, - }, - ), - ]) -} diff --git a/crates/router/src/configs/secrets_transformers.rs b/crates/router/src/configs/secrets_transformers.rs index 45a6903cb9..775c08da76 100644 --- a/crates/router/src/configs/secrets_transformers.rs +++ b/crates/router/src/configs/secrets_transformers.rs @@ -224,25 +224,6 @@ impl SecretsHandler for settings::ApplepayMerchantConfigs { } } -#[async_trait::async_trait] -impl SecretsHandler for settings::PaymentMethodAuth { - async fn convert_to_raw_secret( - value: SecretStateContainer, - secret_management_client: &dyn SecretManagementInterface, - ) -> CustomResult, SecretsManagementError> { - let payment_method_auth = value.get_inner(); - - let pm_auth_key = secret_management_client - .get_secret(payment_method_auth.pm_auth_key.clone()) - .await?; - - Ok(value.transition_state(|payment_method_auth| Self { - pm_auth_key, - ..payment_method_auth - })) - } -} - #[async_trait::async_trait] impl SecretsHandler for settings::KeyManagerConfig { async fn convert_to_raw_secret( diff --git a/crates/router/src/configs/settings.rs b/crates/router/src/configs/settings.rs index 67f7e46770..e8c43903e4 100644 --- a/crates/router/src/configs/settings.rs +++ b/crates/router/src/configs/settings.rs @@ -6,7 +6,7 @@ use std::{ #[cfg(feature = "olap")] use analytics::{opensearch::OpenSearchConfig, ReportConfig}; -use api_models::{enums, payment_methods::RequiredFieldInfo}; +use api_models::enums; use common_utils::{ext_traits::ConfigExt, id_type, types::theme::EmailThemeConfig}; use config::{Environment, File}; use error_stack::ResultExt; @@ -25,6 +25,11 @@ use hyperswitch_interfaces::secrets_interface::secret_state::{ RawSecret, SecretState, SecretStateContainer, SecuredSecret, }; use masking::Secret; +pub use payment_methods::configs::settings::{ + ConnectorFields, EligiblePaymentMethods, Mandates, PaymentMethodAuth, PaymentMethodType, + RequiredFieldFinal, RequiredFields, SupportedConnectorsForMandate, + SupportedPaymentMethodTypesForMandate, SupportedPaymentMethodsForMandate, ZeroMandates, +}; use redis_interface::RedisSettings; pub use router_env::config::{Log, LogConsole, LogFile, LogTelemetry}; use rust_decimal::Decimal; @@ -416,19 +421,6 @@ pub struct ForexApi { pub redis_ttl_in_seconds: u32, } -#[derive(Debug, Deserialize, Clone, Default)] -pub struct PaymentMethodAuth { - pub redis_expiry: i64, - pub pm_auth_key: Secret, -} - -#[derive(Debug, Deserialize, Clone, Default)] -#[serde(default)] -pub struct EligiblePaymentMethods { - #[serde(deserialize_with = "deserialize_hashset")] - pub sdk_eligible_payment_methods: HashSet, -} - #[derive(Debug, Deserialize, Clone, Default)] pub struct DefaultExchangeRates { pub base_currency: String, @@ -510,17 +502,6 @@ pub struct CorsSettings { pub allowed_methods: HashSet, } -#[derive(Debug, Deserialize, Clone)] -pub struct Mandates { - pub supported_payment_methods: SupportedPaymentMethodsForMandate, - pub update_mandate_supported: SupportedPaymentMethodsForMandate, -} - -#[derive(Debug, Deserialize, Clone)] -pub struct ZeroMandates { - pub supported_payment_methods: SupportedPaymentMethodsForMandate, -} - #[derive(Debug, Deserialize, Clone, Default)] pub struct NetworkTransactionIdSupportedConnectors { #[serde(deserialize_with = "deserialize_hashset")] @@ -545,22 +526,6 @@ pub struct NetworkTokenizationService { pub check_token_status_url: url::Url, } -#[derive(Debug, Deserialize, Clone)] -pub struct SupportedPaymentMethodsForMandate( - pub HashMap, -); - -#[derive(Debug, Deserialize, Clone)] -pub struct SupportedPaymentMethodTypesForMandate( - pub HashMap, -); - -#[derive(Debug, Deserialize, Clone)] -pub struct SupportedConnectorsForMandate { - #[serde(deserialize_with = "deserialize_hashset")] - pub connector_list: HashSet, -} - #[derive(Debug, Deserialize, Clone, Default)] pub struct PaymentMethodTokenFilter { #[serde(deserialize_with = "deserialize_hashset")] @@ -647,34 +612,6 @@ pub struct NotAvailableFlows { #[cfg_attr(feature = "v2", derive(Default))] // Configs are read from the config file in config/payout_required_fields.toml pub struct PayoutRequiredFields(pub HashMap); -#[derive(Debug, Deserialize, Clone)] -#[cfg_attr(feature = "v2", derive(Default))] // Configs are read from the config file in config/payment_required_fields.toml -pub struct RequiredFields(pub HashMap); - -#[derive(Debug, Deserialize, Clone)] -pub struct PaymentMethodType(pub HashMap); - -#[derive(Debug, Deserialize, Clone)] -pub struct ConnectorFields { - pub fields: HashMap, -} - -#[cfg(feature = "v1")] -#[derive(Debug, Deserialize, Clone)] -pub struct RequiredFieldFinal { - pub mandate: HashMap, - pub non_mandate: HashMap, - pub common: HashMap, -} - -#[cfg(feature = "v2")] -#[derive(Debug, Deserialize, Clone)] -pub struct RequiredFieldFinal { - pub mandate: Option>, - pub non_mandate: Option>, - pub common: Option>, -} - #[derive(Debug, Default, Deserialize, Clone)] #[serde(default)] pub struct Secrets { diff --git a/crates/router/src/core/payment_methods/cards.rs b/crates/router/src/core/payment_methods/cards.rs index 6227ce8c9f..e9fefffbb0 100644 --- a/crates/router/src/core/payment_methods/cards.rs +++ b/crates/router/src/core/payment_methods/cards.rs @@ -4,6 +4,9 @@ use std::{ str::FromStr, }; +use ::payment_methods::configs::payment_connector_required_fields::{ + get_billing_required_fields, get_shipping_required_fields, +}; #[cfg(all( any(feature = "v1", feature = "v2"), not(feature = "payment_methods_v2") @@ -91,10 +94,7 @@ use crate::routes::app::SessionStateInfo; #[cfg(feature = "payouts")] use crate::types::domain::types::AsyncLift; use crate::{ - configs::{ - defaults::{get_billing_required_fields, get_shipping_required_fields}, - settings, - }, + configs::settings, consts as router_consts, core::{ errors::{self, StorageErrorExt},