feat(connector): [BANKOFAMERICA] Implement Apple Pay

crates/router/src/connector/bankofamerica/transformers.rs

@@ -6,8 +6,8 @@ use serde::{Deserialize, Serialize};
 
 use crate::{
     connector::utils::{
-        self, AddressDetailsData, CardData, CardIssuer, PaymentsAuthorizeRequestData,
-        PaymentsSyncRequestData, RouterData,
+        self, AddressDetailsData, ApplePayDecrypt, CardData, CardIssuer,
+        PaymentsAuthorizeRequestData, PaymentsSyncRequestData, RouterData,
     },
     consts,
     core::errors,
@@ -16,6 +16,7 @@ use crate::{
         api::{self, enums as api_enums},
         storage::enums,
         transformers::ForeignFrom,
+        ApplePayPredecryptData,
     },
 };
 
@@ -110,11 +111,18 @@ pub struct GooglePayPaymentInformation {
     fluid_data: FluidData,
 }
 
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ApplePayPaymentInformation {
+    tokenized_card: TokenizedCard,
+}
+
 #[derive(Debug, Serialize)]
 #[serde(untagged)]
 pub enum PaymentInformation {
     Cards(CardPaymentInformation),
     GooglePay(GooglePayPaymentInformation),
+    ApplePay(ApplePayPaymentInformation),
 }
 
 #[derive(Debug, Serialize)]
@@ -128,6 +136,16 @@ pub struct Card {
     card_type: Option<String>,
 }
 
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TokenizedCard {
+    number: Secret<String>,
+    expiration_month: Secret<String>,
+    expiration_year: Secret<String>,
+    cryptogram: Secret<String>,
+    transaction_type: TransactionType,
+}
+
 #[derive(Debug, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct FluidData {
@@ -215,6 +233,12 @@ impl From<PaymentSolution> for String {
     }
 }
 
+#[derive(Debug, Serialize)]
+pub enum TransactionType {
+    #[serde(rename = "1")]
+    ApplePay,
+}
+
 impl
     From<(
         &BankOfAmericaRouterData<&types::PaymentsAuthorizeRouterData>,
@@ -320,6 +344,48 @@ impl
     }
 }
 
+impl
+    TryFrom<(
+        &BankOfAmericaRouterData<&types::PaymentsAuthorizeRouterData>,
+        Box<ApplePayPredecryptData>,
+    )> for BankOfAmericaPaymentsRequest
+{
+    type Error = error_stack::Report<errors::ConnectorError>;
+    fn try_from(
+        (item, apple_pay_data): (
+            &BankOfAmericaRouterData<&types::PaymentsAuthorizeRouterData>,
+            Box<ApplePayPredecryptData>,
+        ),
+    ) -> Result<Self, Self::Error> {
+        let email = item.router_data.request.get_email()?;
+        let bill_to = build_bill_to(item.router_data.get_billing()?, email)?;
+        let order_information = OrderInformationWithBill::from((item, bill_to));
+        let processing_information =
+            ProcessingInformation::from((item, Some(PaymentSolution::ApplePay)));
+        let client_reference_information = ClientReferenceInformation::from(item);
+
+        let expiration_month = apple_pay_data.get_applepay_decrypted_expiration_month()?;
+        let expiration_year = apple_pay_data.get_applepay_decrypted_expiration_year_4_digit()?;
+
+        let payment_information = PaymentInformation::ApplePay(ApplePayPaymentInformation {
+            tokenized_card: TokenizedCard {
+                number: apple_pay_data.application_primary_account_number,
+                cryptogram: apple_pay_data.payment_data.online_payment_cryptogram,
+                transaction_type: TransactionType::ApplePay,
+                expiration_year,
+                expiration_month,
+            },
+        });
+
+        Ok(Self {
+            processing_information,
+            payment_information,
+            order_information,
+            client_reference_information,
+        })
+    }
+}
+
 impl
     TryFrom<(
         &BankOfAmericaRouterData<&types::PaymentsAuthorizeRouterData>,
@@ -368,6 +434,17 @@ impl TryFrom<&BankOfAmericaRouterData<&types::PaymentsAuthorizeRouterData>>
         match item.router_data.request.payment_method_data.clone() {
             payments::PaymentMethodData::Card(ccard) => Self::try_from((item, ccard)),
             payments::PaymentMethodData::Wallet(wallet_data) => match wallet_data {
+                payments::WalletData::ApplePay(_) => {
+                    let payment_method_token = item.router_data.get_payment_method_token()?;
+                    match payment_method_token {
+                        types::PaymentMethodToken::ApplePayDecrypt(decrypt_data) => {
+                            Self::try_from((item, decrypt_data))
+                        }
+                        types::PaymentMethodToken::Token(_) => {
+                            Err(errors::ConnectorError::InvalidWalletToken)?
+                        }
+                    }
+                }
                 payments::WalletData::GooglePay(google_pay_data) => {
                     Self::try_from((item, google_pay_data))
                 }
@@ -378,7 +455,6 @@ impl TryFrom<&BankOfAmericaRouterData<&types::PaymentsAuthorizeRouterData>>
                 | payments::WalletData::KakaoPayRedirect(_)
                 | payments::WalletData::GoPayRedirect(_)
                 | payments::WalletData::GcashRedirect(_)
-                | payments::WalletData::ApplePay(_)
                 | payments::WalletData::ApplePayRedirect(_)
                 | payments::WalletData::ApplePayThirdPartySdk(_)
                 | payments::WalletData::DanaRedirect {}

crates/router/src/connector/utils.rs

@@ -26,7 +26,7 @@ use crate::{
     pii::PeekInterface,
     types::{
         self, api, storage::payment_attempt::PaymentAttemptExt, transformers::ForeignTryFrom,
-        PaymentsCancelData, ResponseId,
+        ApplePayPredecryptData, PaymentsCancelData, ResponseId,
     },
     utils::{OptionExt, ValueExt},
 };
@@ -853,6 +853,33 @@ impl ApplePay for payments::ApplePayWalletData {
     }
 }
 
+pub trait ApplePayDecrypt {
+    fn get_applepay_decrypted_expiration_month(&self) -> Result<Secret<String>, Error>;
+    fn get_applepay_decrypted_expiration_year_4_digit(&self) -> Result<Secret<String>, Error>;
+}
+
+impl ApplePayDecrypt for Box<ApplePayPredecryptData> {
+    fn get_applepay_decrypted_expiration_year_4_digit(&self) -> Result<Secret<String>, Error> {
+        Ok(Secret::new(format!(
+            "20{}",
+            self.application_expiration_date
+                .peek()
+                .get(0..2)
+                .ok_or(errors::ConnectorError::RequestEncodingFailed)?
+        )))
+    }
+
+    fn get_applepay_decrypted_expiration_month(&self) -> Result<Secret<String>, Error> {
+        Ok(Secret::new(
+            self.application_expiration_date
+                .peek()
+                .get(2..4)
+                .ok_or(errors::ConnectorError::RequestEncodingFailed)?
+                .to_owned(),
+        ))
+    }
+}
+
 pub trait CryptoData {
     fn get_pay_currency(&self) -> Result<String, Error>;
 }