fix(core): Include surcharge amount in frm request

crates/data_models/src/payments.rs

@@ -15,7 +15,9 @@ pub struct PaymentIntent {
     pub payment_id: String,
     pub merchant_id: String,
     pub status: storage_enums::IntentStatus,
-    pub amount: i64,
+    /// This amount may not be equal to authorized_amount due to surcharge<br>
+    /// Authorized amount can be fetched from PaymentAttempt
+    pub original_amount: i64,
     pub currency: Option<storage_enums::Currency>,
     pub amount_captured: Option<i64>,
     pub customer_id: Option<String>,

crates/data_models/src/payments/payment_attempt.rs

@@ -1,5 +1,6 @@
 use api_models::enums::Connector;
 use common_enums as storage_enums;
+use diesel_models::PaymentAttempt as DieselPaymentAttempt;
 use serde::{Deserialize, Serialize};
 use time::PrimitiveDateTime;
 
@@ -106,15 +107,12 @@ pub struct PaymentAttempt {
     pub merchant_id: String,
     pub attempt_id: String,
     pub status: storage_enums::AttemptStatus,
-    pub amount: i64,
-    pub net_amount: i64,
+    pub amount: AttemptAmount,
     pub currency: Option<storage_enums::Currency>,
     pub save_to_locker: Option<bool>,
     pub connector: Option<String>,
     pub error_message: Option<String>,
     pub offer_amount: Option<i64>,
-    pub surcharge_amount: Option<i64>,
-    pub tax_amount: Option<i64>,
     pub payment_method_id: Option<String>,
     pub payment_method: Option<storage_enums::PaymentMethod>,
     pub connector_transaction_id: Option<String>,
@@ -157,9 +155,64 @@ pub struct PaymentAttempt {
     pub unified_message: Option<String>,
 }
 
-impl PaymentAttempt {
-    pub fn get_total_amount(&self) -> i64 {
-        self.amount + self.surcharge_amount.unwrap_or(0) + self.tax_amount.unwrap_or(0)
+#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+pub struct AttemptAmount {
+    amount: i64,
+    surcharge_amount: Option<i64>,
+    tax_amount: Option<i64>,
+    net_amount: i64,
+}
+
+pub trait GetAttemptAmount {
+    fn get_attempt_amount(&self) -> AttemptAmount;
+}
+
+impl GetAttemptAmount for DieselPaymentAttempt {
+    fn get_attempt_amount(&self) -> AttemptAmount {
+        AttemptAmount {
+            amount: self.amount,
+            surcharge_amount: self.surcharge_amount,
+            tax_amount: self.tax_amount,
+            net_amount: self.get_or_calculate_net_amount(),
+        }
+    }
+}
+
+impl GetAttemptAmount for PaymentAttemptNew {
+    fn get_attempt_amount(&self) -> AttemptAmount {
+        AttemptAmount {
+            amount: self.amount,
+            surcharge_amount: self.surcharge_amount,
+            tax_amount: self.tax_amount,
+            net_amount: self.calculate_net_amount(),
+        }
+    }
+}
+
+impl AttemptAmount {
+    pub fn set_original_amount(&mut self, amount: i64) {
+        self.amount = amount;
+        self.net_amount = self.amount + self.get_total_surcharge_amount().unwrap_or(0);
+    }
+    pub fn set_surcharge_amount(&mut self, surcharge_amount: i64) {
+        self.surcharge_amount = Some(surcharge_amount);
+        self.net_amount = self.amount + self.get_total_surcharge_amount().unwrap_or(0);
+    }
+    pub fn set_tax_amount(&mut self, tax_amount: i64) {
+        self.tax_amount = Some(tax_amount);
+        self.net_amount = self.amount + self.get_total_surcharge_amount().unwrap_or(0);
+    }
+    pub fn get_authorize_amount(&self) -> i64 {
+        self.net_amount
+    }
+    pub fn get_original_amount(&self) -> i64 {
+        self.amount
+    }
+    pub fn get_surcharge_amount(&self) -> Option<i64> {
+        self.surcharge_amount
+    }
+    pub fn get_tax_amount_on_surcharge(&self) -> Option<i64> {
+        self.tax_amount
     }
     pub fn get_total_surcharge_amount(&self) -> Option<i64> {
         self.surcharge_amount

crates/diesel_models/src/payment_attempt.rs

@@ -146,11 +146,6 @@ impl PaymentAttemptNew {
         self.amount + self.surcharge_amount.unwrap_or(0) + self.tax_amount.unwrap_or(0)
     }
 
-    pub fn get_or_calculate_net_amount(&self) -> i64 {
-        self.net_amount
-            .unwrap_or_else(|| self.calculate_net_amount())
-    }
-
     pub fn populate_derived_fields(self) -> Self {
         let mut payment_attempt_new = self;
         payment_attempt_new.net_amount = Some(payment_attempt_new.calculate_net_amount());

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

@@ -1986,9 +1986,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/connector/utils.rs

@@ -118,7 +118,8 @@ where
             enums::AttemptStatus::Charged => {
                 let captured_amount =
                     types::Capturable::get_captured_amount(&self.request, payment_data);
-                let total_capturable_amount = payment_data.payment_attempt.get_total_amount();
+                let total_capturable_amount =
+                    payment_data.payment_attempt.amount.get_authorize_amount();
                 if Some(total_capturable_amount) == captured_amount {
                     enums::AttemptStatus::Charged
                 } else if captured_amount.is_some() {

crates/router/src/core/fraud_check.rs

@@ -81,6 +81,16 @@ where
         .payment_attempt
         .connector_transaction_id
         .clone();
+    if let Some(surcharge_details) = &payment_data.surcharge_details {
+        frm_data
+            .payment_attempt
+            .amount
+            .set_surcharge_amount(surcharge_details.surcharge_amount);
+        frm_data
+            .payment_attempt
+            .amount
+            .set_tax_amount(surcharge_details.tax_on_surcharge_amount);
+    }
 
     let mut router_data = frm_data
         .construct_router_data(

crates/router/src/core/fraud_check/flows/checkout_flow.rs

@@ -69,7 +69,7 @@ impl ConstructFlowSpecificData<frm_api::Checkout, FraudCheckCheckoutData, FraudC
             connector_meta_data: None,
             amount_captured: None,
             request: FraudCheckCheckoutData {
-                amount: self.payment_attempt.amount,
+                amount: self.payment_attempt.amount.get_authorize_amount(),
                 order_details: self.order_details.clone(),
                 currency: self.payment_attempt.currency,
                 browser_info,

crates/router/src/core/fraud_check/flows/fulfillment_flow.rs

@@ -77,7 +77,7 @@ pub async fn construct_fulfillment_router_data<'a>(
         connector_meta_data: merchant_connector_account.get_metadata(),
         amount_captured: payment_intent.amount_captured,
         request: FraudCheckFulfillmentData {
-            amount: payment_attempt.amount,
+            amount: payment_attempt.amount.get_authorize_amount(),
             order_details: payment_intent.order_details.clone(),
             fulfillment_req: fulfillment_request,
         },

crates/router/src/core/fraud_check/flows/record_return.rs

@@ -68,7 +68,7 @@ impl ConstructFlowSpecificData<RecordReturn, FraudCheckRecordReturnData, FraudCh
             connector_meta_data: None,
             amount_captured: None,
             request: FraudCheckRecordReturnData {
-                amount: self.payment_attempt.amount,
+                amount: self.payment_attempt.amount.get_authorize_amount(),
                 refund_method: RefundMethod::OriginalPaymentInstrument, //we dont consume this data now in payments...hence hardcoded
                 currency,
                 refund_transaction_id: self.refund.clone().map(|refund| refund.refund_id),

crates/router/src/core/fraud_check/flows/sale_flow.rs

@@ -64,7 +64,7 @@ impl ConstructFlowSpecificData<frm_api::Sale, FraudCheckSaleData, FraudCheckResp
             connector_meta_data: None,
             amount_captured: None,
             request: FraudCheckSaleData {
-                amount: self.payment_attempt.amount,
+                amount: self.payment_attempt.amount.get_authorize_amount(),
                 order_details: self.order_details.clone(),
             },
             response: Ok(FraudCheckResponseData::TransactionResponse {

crates/router/src/core/fraud_check/flows/transaction_flow.rs

@@ -75,7 +75,7 @@ impl
             connector_meta_data: None,
             amount_captured: None,
             request: FraudCheckTransactionData {
-                amount: self.payment_attempt.amount,
+                amount: self.payment_attempt.amount.get_authorize_amount(),
                 order_details: self.order_details.clone(),
                 currency,
                 payment_method,

crates/router/src/core/payment_link.rs

@@ -105,7 +105,7 @@ pub async fn intiate_payment_link_flow(
         payment_intent.client_secret.clone(),
     )?;
     let amount = currency
-        .to_currency_base_unit(payment_intent.amount)
+        .to_currency_base_unit(payment_intent.original_amount)
         .into_report()
         .change_context(errors::ApiErrorResponse::CurrencyConversionFailed)?;
     let order_details = validate_order_details(payment_intent.order_details.clone(), currency)?;

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

@@ -1044,7 +1044,7 @@ pub async fn list_payment_methods(
         .transpose()?;
 
     let payment_type = payment_attempt.as_ref().map(|pa| {
-        let amount = api::Amount::from(pa.amount);
+        let amount = api::Amount::from(pa.amount.get_authorize_amount());
         let mandate_type = if pa.mandate_id.is_some() {
             Some(api::MandateTransactionType::RecurringMandateTransaction)
         } else if pa.mandate_details.is_some() {
@@ -1088,8 +1088,14 @@ pub async fn list_payment_methods(
     )
     .await?;
 
-    // filter out connectors based on the business country
-    let filtered_mcas = helpers::filter_mca_based_on_business_profile(all_mcas, profile_id);
+    // filter out connectors based on the business profile and connector types
+    let filtered_mcas = {
+        let filter_list = helpers::filter_mca_based_on_business_profile(all_mcas, profile_id);
+        filter_list
+            .into_iter()
+            .filter(|mca| mca.connector_type == common_enums::ConnectorType::FizOperations)
+            .collect::<Vec<_>>()
+    };
 
     logger::debug!(mca_before_filtering=?filtered_mcas);
 
@@ -1767,7 +1773,7 @@ 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() {
+    if payment_attempt.amount.get_surcharge_amount().is_some() {
         Ok(api_surcharge_decision_configs::MerchantSurchargeConfigs::default())
     } else {
         let algorithm_ref: routing_types::RoutingAlgorithmRef = merchant_account
@@ -1820,7 +1826,7 @@ 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() {
+    if payment_attempt.amount.get_surcharge_amount().is_some() {
         Ok(())
     } else {
         let algorithm_ref: routing_types::RoutingAlgorithmRef = merchant_account
@@ -2311,10 +2317,10 @@ fn filter_payment_amount_based(
     payment_intent: &storage::PaymentIntent,
     pm: &RequestPaymentMethodTypes,
 ) -> bool {
-    let amount = payment_intent.amount;
+    let amount = payment_intent.original_amount;
     (pm.maximum_amount.map_or(true, |amt| amount <= amt.into())
         && pm.minimum_amount.map_or(true, |amt| amount >= amt.into()))
-        || payment_intent.amount == 0
+        || payment_intent.original_amount == 0
 }
 
 async fn filter_payment_mandate_based(

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

@@ -294,7 +294,7 @@ fn get_surcharge_details_from_surcharge_output(
     let surcharge_amount = match surcharge_details.surcharge.clone() {
         surcharge_decision_configs::SurchargeOutput::Fixed { amount } => amount,
         surcharge_decision_configs::SurchargeOutput::Rate(percentage) => percentage
-            .apply_and_ceil_result(payment_attempt.amount)
+            .apply_and_ceil_result(payment_attempt.amount.get_original_amount())
             .change_context(ConfigError::DslExecutionError)
             .attach_printable("Failed to Calculate surcharge amount by applying percentage")?,
     };
@@ -309,8 +309,9 @@ fn get_surcharge_details_from_surcharge_output(
         })
         .transpose()?
         .unwrap_or(0);
+    let original_amount = payment_attempt.amount.get_original_amount();
     Ok(types::SurchargeDetails {
-        original_amount: payment_attempt.amount,
+        original_amount,
         surcharge: match surcharge_details.surcharge {
             surcharge_decision_configs::SurchargeOutput::Fixed { amount } => {
                 common_utils_types::Surcharge::Fixed(amount)
@@ -322,7 +323,7 @@ fn get_surcharge_details_from_surcharge_output(
         tax_on_surcharge: surcharge_details.tax_on_surcharge,
         surcharge_amount,
         tax_on_surcharge_amount,
-        final_amount: payment_attempt.amount + surcharge_amount + tax_on_surcharge_amount,
+        final_amount: original_amount + surcharge_amount + tax_on_surcharge_amount,
     })
 }
 

crates/router/src/core/payments.rs

@@ -173,6 +173,10 @@ where
     let mut connector_http_status_code = None;
     let mut external_latency = None;
     if let Some(connector_details) = connector {
+        operation
+            .to_domain()?
+            .populate_payment_data(state, &mut payment_data, &merchant_account)
+            .await?;
         // Fetch and check FRM configs
         #[cfg(feature = "frm")]
         let mut frm_info = None;
@@ -499,7 +503,9 @@ where
         .surcharge_applicable
         .unwrap_or(false)
     {
-        if let Some(surcharge_details) = payment_data.payment_attempt.get_surcharge_details() {
+        if let Some(surcharge_details) =
+            payment_data.payment_attempt.get_request_surcharge_details()
+        {
             // if retry payment, surcharge would have been populated from the previous attempt. Use the same surcharge
             let surcharge_details =
                 types::SurchargeDetails::from((&surcharge_details, &payment_data.payment_attempt));
@@ -541,16 +547,12 @@ where
 
         payment_data.surcharge_details = calculated_surcharge_details;
     } else {
-        let surcharge_details =
-            payment_data
-                .payment_attempt
-                .get_surcharge_details()
-                .map(|surcharge_details| {
-                    types::SurchargeDetails::from((
-                        &surcharge_details,
-                        &payment_data.payment_attempt,
-                    ))
-                });
+        let surcharge_details = payment_data
+            .payment_attempt
+            .get_request_surcharge_details()
+            .map(|surcharge_details| {
+                types::SurchargeDetails::from((&surcharge_details, &payment_data.payment_attempt))
+            });
         payment_data.surcharge_details = surcharge_details;
     }
     Ok(())
@@ -578,13 +580,17 @@ pub async fn call_surcharge_decision_management_for_session_flow<O>(
 where
     O: Send + Clone + Sync,
 {
-    if let Some(surcharge_amount) = payment_data.payment_attempt.surcharge_amount {
-        let tax_on_surcharge_amount = payment_data.payment_attempt.tax_amount.unwrap_or(0);
-        let final_amount =
-            payment_data.payment_attempt.amount + surcharge_amount + tax_on_surcharge_amount;
+    if let Some(surcharge_amount) = payment_data.payment_attempt.amount.get_surcharge_amount() {
+        let tax_on_surcharge_amount = payment_data
+            .payment_attempt
+            .amount
+            .get_tax_amount_on_surcharge()
+            .unwrap_or(0);
+        let original_amount = payment_data.payment_attempt.amount.get_original_amount();
+        let final_amount = original_amount + surcharge_amount + tax_on_surcharge_amount;
         Ok(Some(api::SessionSurchargeDetails::PreDetermined(
             types::SurchargeDetails {
-                original_amount: payment_data.payment_attempt.amount,
+                original_amount,
                 surcharge: Surcharge::Fixed(surcharge_amount),
                 tax_on_surcharge: None,
                 surcharge_amount,
@@ -1029,11 +1035,6 @@ where
             merchant_connector_account.get_mca_id();
     }
 
-    operation
-        .to_domain()?
-        .populate_payment_data(state, payment_data, merchant_account)
-        .await?;
-
     let (pd, tokenization_action) = get_connector_tokenization_action_when_confirm_true(
         state,
         operation,