refactor(connector): [Mifinity] fix redirection after payment completion and handle 5xx error (#5250)

crates/router/src/connector/mifinity.rs

@@ -2,16 +2,17 @@ pub mod transformers;
 
 use std::fmt::Debug;
 
-use error_stack::{report, ResultExt};
+use error_stack::{report, Report, ResultExt};
 use masking::ExposeInterface;
 use transformers as mifinity;
 
 use self::transformers::auth_headers;
 use crate::{
     configs::settings,
+    consts,
     core::errors::{self, CustomResult},
     events::connector_api_logs::ConnectorEvent,
-    headers,
+    headers, logger,
     services::{
         self,
         request::{self, Mask},
@@ -112,39 +113,59 @@ impl ConnectorCommon for Mifinity {
         res: Response,
         event_builder: Option<&mut ConnectorEvent>,
     ) -> CustomResult<ErrorResponse, errors::ConnectorError> {
-        let response: mifinity::MifinityErrorResponse = res
+        if res.response.is_empty() {
-            .response
+            Ok(ErrorResponse {
-            .parse_struct("MifinityErrorResponse")
+                status_code: res.status_code,
-            .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
+                code: consts::NO_ERROR_CODE.to_string(),
+                message: consts::NO_ERROR_MESSAGE.to_string(),
+                reason: Some(consts::CONNECTOR_UNAUTHORIZED_ERROR.to_string()),
+                attempt_status: None,
+                connector_transaction_id: None,
+            })
+        } else {
+            let response: Result<
+                mifinity::MifinityErrorResponse,
+                Report<common_utils::errors::ParsingError>,
+            > = res.response.parse_struct("MifinityErrorResponse");
 
-        event_builder.map(|i| i.set_response_body(&response));
+            match response {
-        router_env::logger::info!(connector_response=?response);
+                Ok(response) => {
+                    event_builder.map(|i| i.set_response_body(&response));
+                    router_env::logger::info!(connector_response=?response);
+                    Ok(ErrorResponse {
+                        status_code: res.status_code,
+                        code: response
+                            .errors
+                            .iter()
+                            .map(|error| error.error_code.clone())
+                            .collect::<Vec<String>>()
+                            .join(" & "),
+                        message: response
+                            .errors
+                            .iter()
+                            .map(|error| error.message.clone())
+                            .collect::<Vec<String>>()
+                            .join(" & "),
+                        reason: Some(
+                            response
+                                .errors
+                                .iter()
+                                .map(|error| error.message.clone())
+                                .collect::<Vec<String>>()
+                                .join(" & "),
+                        ),
+                        attempt_status: None,
+                        connector_transaction_id: None,
+                    })
+                }
 
-        Ok(ErrorResponse {
+                Err(error_msg) => {
-            status_code: res.status_code,
+                    event_builder.map(|event| event.set_error(serde_json::json!({"error": res.response.escape_ascii().to_string(), "status_code": res.status_code})));
-            code: response
+                    logger::error!(deserialization_error =? error_msg);
-                .errors
+                    crate::utils::handle_json_response_deserialization_failure(res, "mifinity")
-                .iter()
+                }
-                .map(|error| error.error_code.clone())
+            }
-                .collect::<Vec<String>>()
+        }
-                .join(" & "),
-            message: response
-                .errors
-                .iter()
-                .map(|error| error.message.clone())
-                .collect::<Vec<String>>()
-                .join(" & "),
-            reason: Some(
-                response
-                    .errors
-                    .iter()
-                    .map(|error| error.message.clone())
-                    .collect::<Vec<String>>()
-                    .join(" & "),
-            ),
-            attempt_status: None,
-            connector_transaction_id: None,
-        })
     }
 }
 

crates/router/src/services/api.rs

@@ -1877,10 +1877,11 @@ pub fn build_redirection_form(
         RedirectForm::Mifinity {
             initialization_token,
         } => {
+            let mifinity_base_url = config.connectors.mifinity.base_url;
             maud::html! {
                         (maud::DOCTYPE)
                         head {
-                            (PreEscaped(r#"<script src='https://demo.mifinity.com/widgets/sgpg.js?58190a411dc3'></script>"#))
+                            (PreEscaped(format!(r#"<script src='{mifinity_base_url}widgets/sgpg.js?58190a411dc3'></script>"#)))
                         }
 
                         (PreEscaped(format!("<div id='widget-container'></div>
@@ -1888,9 +1889,11 @@ pub fn build_redirection_form(
 		  var widget = showPaymentIframe('widget-container', {{
 			  token: '{initialization_token}',
 			  complete: function() {{
-				  setTimeout(function() {{
+                var f = document.createElement('form');
-					widget.close();
+                f.action=window.location.pathname.replace(/payments\\/redirect\\/(\\w+)\\/(\\w+)\\/\\w+/, \"payments/$1/$2/redirect/response/mifinity\");
-				  }}, 5000);
+                f.method='GET';
+                document.body.appendChild(f);
+                f.submit();
 			  }}
 		   }});
 	   </script>")))