feat(connector): [FISERV] Populated Network Advice Fields in ErrorResponse & Added Integrity Check Suppport for Payment & Refund Flows

Author: Sayak Bhattacharya

crates/hyperswitch_connectors/src/connectors/fiserv.rs

@@ -51,6 +51,7 @@ use uuid::Uuid;
 use crate::{
     constants::headers,
     types::ResponseRouterData,
+    utils as connector_utils,
     utils::{construct_not_implemented_error_report, convert_amount},
 };
 
@@ -168,37 +169,64 @@ impl ConnectorCommon for Fiserv {
         event_builder.map(|i| i.set_error_response_body(&response));
         router_env::logger::info!(connector_response=?response);
 
-        let fiserv::ErrorResponse { error, details } = response;
-
-        Ok(error
-            .or(details)
-            .and_then(|error_details| {
-                error_details.first().map(|first_error| ErrorResponse {
-                    code: first_error
-                        .code
-                        .to_owned()
-                        .unwrap_or_else(|| consts::NO_ERROR_CODE.to_string()),
-                    message: first_error.message.to_owned(),
-                    reason: first_error.field.to_owned(),
-                    status_code: res.status_code,
-                    attempt_status: None,
-                    connector_transaction_id: None,
-                    network_advice_code: None,
-                    network_decline_code: None,
-                    network_error_message: None,
-                })
-            })
-            .unwrap_or(ErrorResponse {
-                code: consts::NO_ERROR_CODE.to_string(),
-                message: consts::NO_ERROR_MESSAGE.to_string(),
-                reason: None,
-                status_code: res.status_code,
-                attempt_status: None,
-                connector_transaction_id: None,
-                network_advice_code: None,
-                network_decline_code: None,
-                network_error_message: None,
-            }))
+        let error_details_opt = response.error.as_ref().and_then(|v| v.first());
+
+        let (
+            code,
+            message,
+            reason,
+            network_advice_code,
+            network_decline_code,
+            network_error_message,
+        ) = if let Some(first_error) = error_details_opt {
+            let code = first_error
+                .code
+                .clone()
+                .unwrap_or_else(|| consts::NO_ERROR_CODE.to_string());
+
+            let message = first_error
+                .message
+                .clone()
+                .unwrap_or_else(|| consts::NO_ERROR_CODE.to_string());
+
+            let reason = first_error.additional_info.clone();
+
+            let network_advice_code = first_error.message.clone();
+
+            let network_decline_code = first_error.code.clone();
+
+            let network_error_message = first_error.additional_info.clone();
+
+            (
+                code,
+                message,
+                reason,
+                network_advice_code,
+                network_decline_code,
+                network_error_message,
+            )
+        } else {
+            (
+                consts::NO_ERROR_CODE.to_string(),
+                consts::NO_ERROR_MESSAGE.to_string(),
+                None,
+                None,
+                None,
+                None,
+            )
+        };
+
+        Ok(ErrorResponse {
+            code,
+            message,
+            reason,
+            status_code: res.status_code,
+            attempt_status: None,
+            connector_transaction_id: None,
+            network_advice_code,
+            network_decline_code,
+            network_error_message,
+        })
     }
 }
 
@@ -404,14 +432,38 @@ impl ConnectorIntegration<PSync, PaymentsSyncData, PaymentsResponseData> for Fis
             .response
             .parse_struct("Fiserv PaymentSyncResponse")
             .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
+
+        let p_sync_response = response.sync_responses.first().ok_or(
+            errors::ConnectorError::MissingRequiredField {
+                field_name: "P_Sync_Responses[0]",
+            },
+        )?;
+
+        let response_integrity_object = connector_utils::get_sync_integrity_object(
+            self.amount_converter,
+            p_sync_response.payment_receipt.approved_amount.total,
+            p_sync_response
+                .payment_receipt
+                .approved_amount
+                .currency
+                .to_string()
+                .clone(),
+        )?;
+
         event_builder.map(|i| i.set_response_body(&response));
         router_env::logger::info!(connector_response=?response);
-        RouterData::try_from(ResponseRouterData {
+
+        let new_router_data = RouterData::try_from(ResponseRouterData {
             response,
             data: data.clone(),
             http_code: res.status_code,
         })
-        .change_context(errors::ConnectorError::ResponseHandlingFailed)
+        .change_context(errors::ConnectorError::ResponseHandlingFailed);
+
+        new_router_data.map(|mut router_data| {
+            router_data.request.integrity_object = Some(response_integrity_object);
+            router_data
+        })
     }
 
     fn get_error_response(
@@ -483,16 +535,30 @@ impl ConnectorIntegration<Capture, PaymentsCaptureData, PaymentsResponseData> fo
             .response
             .parse_struct("Fiserv Payment Response")
             .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
-
+        let response_integrity_object = connector_utils::get_capture_integrity_object(
+            self.amount_converter,
+            Some(response.payment_receipt.approved_amount.total),
+            response
+                .payment_receipt
+                .approved_amount
+                .currency
+                .to_string()
+                .clone(),
+        )?;
         event_builder.map(|i| i.set_response_body(&response));
         router_env::logger::info!(connector_response=?response);
 
-        RouterData::try_from(ResponseRouterData {
+        let new_router_data = RouterData::try_from(ResponseRouterData {
             response,
             data: data.clone(),
             http_code: res.status_code,
         })
-        .change_context(errors::ConnectorError::ResponseHandlingFailed)
+        .change_context(errors::ConnectorError::ResponseHandlingFailed);
+
+        new_router_data.map(|mut router_data| {
+            router_data.request.integrity_object = Some(response_integrity_object);
+            router_data
+        })
     }
 
     fn get_url(
@@ -595,14 +661,32 @@ impl ConnectorIntegration<Authorize, PaymentsAuthorizeData, PaymentsResponseData
             .response
             .parse_struct("Fiserv PaymentResponse")
             .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
+
+        let response_integrity_object = connector_utils::get_authorise_integrity_object(
+            self.amount_converter,
+            response.payment_receipt.approved_amount.total,
+            response
+                .payment_receipt
+                .approved_amount
+                .currency
+                .to_string()
+                .clone(),
+        )?;
+
         event_builder.map(|i| i.set_response_body(&response));
         router_env::logger::info!(connector_response=?response);
-        RouterData::try_from(ResponseRouterData {
+
+        let new_router_data = RouterData::try_from(ResponseRouterData {
             response,
             data: data.clone(),
             http_code: res.status_code,
         })
-        .change_context(errors::ConnectorError::ResponseHandlingFailed)
+        .change_context(errors::ConnectorError::ResponseHandlingFailed);
+
+        new_router_data.map(|mut router_data| {
+            router_data.request.integrity_object = Some(response_integrity_object);
+            router_data
+        })
     }
 
     fn get_error_response(
@@ -684,14 +768,31 @@ impl ConnectorIntegration<Execute, RefundsData, RefundsResponseData> for Fiserv
             res.response
                 .parse_struct("fiserv RefundResponse")
                 .change_context(errors::ConnectorError::RequestEncodingFailed)?;
+
+        let response_integrity_object = connector_utils::get_refund_integrity_object(
+            self.amount_converter,
+            response.payment_receipt.approved_amount.total,
+            response
+                .payment_receipt
+                .approved_amount
+                .currency
+                .to_string()
+                .clone(),
+        )?;
+
         event_builder.map(|i| i.set_response_body(&response));
         router_env::logger::info!(connector_response=?response);
-        RouterData::try_from(ResponseRouterData {
+        let new_router_data = RouterData::try_from(ResponseRouterData {
             response,
             data: data.clone(),
             http_code: res.status_code,
         })
-        .change_context(errors::ConnectorError::ResponseHandlingFailed)
+        .change_context(errors::ConnectorError::ResponseHandlingFailed);
+
+        new_router_data.map(|mut router_data| {
+            router_data.request.integrity_object = Some(response_integrity_object);
+            router_data
+        })
     }
     fn get_error_response(
         &self,
@@ -767,14 +868,37 @@ impl ConnectorIntegration<RSync, RefundsData, RefundsResponseData> for Fiserv {
             .response
             .parse_struct("Fiserv Refund Response")
             .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
+
+        let r_sync_response = response.sync_responses.first().ok_or(
+            errors::ConnectorError::MissingRequiredField {
+                field_name: "R_Sync_Responses[0]",
+            },
+        )?;
+
+        let response_integrity_object = connector_utils::get_refund_integrity_object(
+            self.amount_converter,
+            r_sync_response.payment_receipt.approved_amount.total,
+            r_sync_response
+                .payment_receipt
+                .approved_amount
+                .currency
+                .to_string()
+                .clone(),
+        )?;
+
         event_builder.map(|i| i.set_response_body(&response));
         router_env::logger::info!(connector_response=?response);
-        RouterData::try_from(ResponseRouterData {
+        let new_router_data = RouterData::try_from(ResponseRouterData {
             response,
             data: data.clone(),
             http_code: res.status_code,
         })
-        .change_context(errors::ConnectorError::ResponseHandlingFailed)
+        .change_context(errors::ConnectorError::ResponseHandlingFailed);
+
+        new_router_data.map(|mut router_data| {
+            router_data.request.integrity_object = Some(response_integrity_object);
+            router_data
+        })
     }
 
     fn get_error_response(