fix(core): return surcharge in payment method list response if passed in create request (#3363)

Co-authored-by: Narayan Bhat <[email protected]>

Author: hrithikesh026

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

@@ -2015,9 +2015,9 @@ impl<F>
                             resource_id: types::ResponseId::NoResponseId,
                             redirection_data,
                             mandate_reference: None,
-                            connector_metadata: Some(
-                                serde_json::json!({"three_ds_data":three_ds_data}),
-                            ),
+                            connector_metadata: Some(serde_json::json!({
+                                "three_ds_data": three_ds_data
+                            })),
                             network_txn_id: None,
                             connector_response_reference_id,
                             incremental_authorization_allowed: None,

crates/router/src/core/payment_methods/cards.rs

@@ -1864,49 +1864,45 @@ pub async fn call_surcharge_decision_management(
     billing_address: Option<domain::Address>,
     response_payment_method_types: &mut [ResponsePaymentMethodsEnabled],
 ) -> errors::RouterResult<api_surcharge_decision_configs::MerchantSurchargeConfigs> {
-    if payment_attempt.surcharge_amount.is_some() {
-        Ok(api_surcharge_decision_configs::MerchantSurchargeConfigs::default())
-    } else {
-        let algorithm_ref: routing_types::RoutingAlgorithmRef = merchant_account
-            .routing_algorithm
-            .clone()
-            .map(|val| val.parse_value("routing algorithm"))
-            .transpose()
-            .change_context(errors::ApiErrorResponse::InternalServerError)
-            .attach_printable("Could not decode the routing algorithm")?
-            .unwrap_or_default();
-        let (surcharge_results, merchant_sucharge_configs) =
-            perform_surcharge_decision_management_for_payment_method_list(
-                &state,
-                algorithm_ref,
-                payment_attempt,
-                &payment_intent,
-                billing_address.as_ref().map(Into::into),
-                response_payment_method_types,
+    let algorithm_ref: routing_types::RoutingAlgorithmRef = merchant_account
+        .routing_algorithm
+        .clone()
+        .map(|val| val.parse_value("routing algorithm"))
+        .transpose()
+        .change_context(errors::ApiErrorResponse::InternalServerError)
+        .attach_printable("Could not decode the routing algorithm")?
+        .unwrap_or_default();
+    let (surcharge_results, merchant_sucharge_configs) =
+        perform_surcharge_decision_management_for_payment_method_list(
+            &state,
+            algorithm_ref,
+            payment_attempt,
+            &payment_intent,
+            billing_address.as_ref().map(Into::into),
+            response_payment_method_types,
+        )
+        .await
+        .change_context(errors::ApiErrorResponse::InternalServerError)
+        .attach_printable("error performing surcharge decision operation")?;
+    if !surcharge_results.is_empty_result() {
+        surcharge_results
+            .persist_individual_surcharge_details_in_redis(&state, business_profile)
+            .await?;
+        let _ = state
+            .store
+            .update_payment_intent(
+                payment_intent,
+                storage::PaymentIntentUpdate::SurchargeApplicableUpdate {
+                    surcharge_applicable: true,
+                    updated_by: merchant_account.storage_scheme.to_string(),
+                },
+                merchant_account.storage_scheme,
             )
             .await
-            .change_context(errors::ApiErrorResponse::InternalServerError)
-            .attach_printable("error performing surcharge decision operation")?;
-        if !surcharge_results.is_empty_result() {
-            surcharge_results
-                .persist_individual_surcharge_details_in_redis(&state, business_profile)
-                .await?;
-            let _ = state
-                .store
-                .update_payment_intent(
-                    payment_intent,
-                    storage::PaymentIntentUpdate::SurchargeApplicableUpdate {
-                        surcharge_applicable: true,
-                        updated_by: merchant_account.storage_scheme.to_string(),
-                    },
-                    merchant_account.storage_scheme,
-                )
-                .await
-                .to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)
-                .attach_printable("Failed to update surcharge_applicable in Payment Intent");
-        }
-        Ok(merchant_sucharge_configs)
+            .to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)
+            .attach_printable("Failed to update surcharge_applicable in Payment Intent");
     }
+    Ok(merchant_sucharge_configs)
 }
 
 pub async fn call_surcharge_decision_management_for_saved_card(
@@ -1917,47 +1913,43 @@ pub async fn call_surcharge_decision_management_for_saved_card(
     payment_intent: storage::PaymentIntent,
     customer_payment_method_response: &mut api::CustomerPaymentMethodsListResponse,
 ) -> errors::RouterResult<()> {
-    if payment_attempt.surcharge_amount.is_some() {
-        Ok(())
-    } else {
-        let algorithm_ref: routing_types::RoutingAlgorithmRef = merchant_account
-            .routing_algorithm
-            .clone()
-            .map(|val| val.parse_value("routing algorithm"))
-            .transpose()
-            .change_context(errors::ApiErrorResponse::InternalServerError)
-            .attach_printable("Could not decode the routing algorithm")?
-            .unwrap_or_default();
-        let surcharge_results = perform_surcharge_decision_management_for_saved_cards(
-            state,
-            algorithm_ref,
-            payment_attempt,
-            &payment_intent,
-            &mut customer_payment_method_response.customer_payment_methods,
-        )
-        .await
+    let algorithm_ref: routing_types::RoutingAlgorithmRef = merchant_account
+        .routing_algorithm
+        .clone()
+        .map(|val| val.parse_value("routing algorithm"))
+        .transpose()
         .change_context(errors::ApiErrorResponse::InternalServerError)
-        .attach_printable("error performing surcharge decision operation")?;
-        if !surcharge_results.is_empty_result() {
-            surcharge_results
-                .persist_individual_surcharge_details_in_redis(state, business_profile)
-                .await?;
-            let _ = state
-                .store
-                .update_payment_intent(
-                    payment_intent,
-                    storage::PaymentIntentUpdate::SurchargeApplicableUpdate {
-                        surcharge_applicable: true,
-                        updated_by: merchant_account.storage_scheme.to_string(),
-                    },
-                    merchant_account.storage_scheme,
-                )
-                .await
-                .to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)
-                .attach_printable("Failed to update surcharge_applicable in Payment Intent");
-        }
-        Ok(())
+        .attach_printable("Could not decode the routing algorithm")?
+        .unwrap_or_default();
+    let surcharge_results = perform_surcharge_decision_management_for_saved_cards(
+        state,
+        algorithm_ref,
+        payment_attempt,
+        &payment_intent,
+        &mut customer_payment_method_response.customer_payment_methods,
+    )
+    .await
+    .change_context(errors::ApiErrorResponse::InternalServerError)
+    .attach_printable("error performing surcharge decision operation")?;
+    if !surcharge_results.is_empty_result() {
+        surcharge_results
+            .persist_individual_surcharge_details_in_redis(state, business_profile)
+            .await?;
+        let _ = state
+            .store
+            .update_payment_intent(
+                payment_intent,
+                storage::PaymentIntentUpdate::SurchargeApplicableUpdate {
+                    surcharge_applicable: true,
+                    updated_by: merchant_account.storage_scheme.to_string(),
+                },
+                merchant_account.storage_scheme,
+            )
+            .await
+            .to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)
+            .attach_printable("Failed to update surcharge_applicable in Payment Intent");
     }
+    Ok(())
 }
 
 #[allow(clippy::too_many_arguments)]