Add files using upload-large-folder tool

diffs/pr_10061/b7bcc6b/diff.json

@@ -0,0 +1,39 @@
+{
+  "commit_sha": "b7bcc6bf9e9eba706f12ecedaf11ec4b9997f2cc",
+  "pr_number": 10061,
+  "rust_files": [
+    "crates/router/src/core/refunds.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/router/src/core/refunds.rs::function::sync_refund_with_gateway",
+      "file": "crates/router/src/core/refunds.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn sync_refund_with_gateway(\n    state: &SessionState,\n    merchant_context: &domain::MerchantContext,\n    payment_attempt: &storage::PaymentAttempt,\n    payment_intent: &storage::PaymentIntent,\n    refund: &diesel_refund::Refund,\n    creds_identifier: Option<String>,\n    split_refunds: Option<SplitRefundsRequest>,\n) -> RouterResult<diesel_refund::Refund> {\n    let connector_id = refund.connector.to_string();\n    let connector: api::ConnectorData = api::ConnectorData::get_connector_by_name(\n        &state.conf.connectors,\n        &connector_id,\n        api::GetToken::Connector,\n        payment_attempt.merchant_connector_id.clone(),\n    )\n    .change_context(errors::ApiErrorResponse::InternalServerError)\n    .attach_printable(\"Failed to get the connector\")?;\n\n    let storage_scheme = merchant_context.get_merchant_account().storage_scheme;\n\n    let currency = payment_attempt.currency.get_required_value(\"currency\")?;\n\n    // Fetch merchant connector account\n    let profile_id = payment_intent\n        .profile_id\n        .as_ref()\n        .get_required_value(\"profile_id\")\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"profile_id is not set in payment_intent\")?;\n\n    let merchant_connector_account = helpers::get_merchant_connector_account(\n        state,\n        merchant_context.get_merchant_account().get_id(),\n        creds_identifier.as_deref(),\n        merchant_context.get_merchant_key_store(),\n        profile_id,\n        &connector_id,\n        payment_attempt.merchant_connector_id.as_ref(),\n    )\n    .await?;\n\n    let mut router_data = core_utils::construct_refund_router_data::<api::RSync>(\n        state,\n        &connector_id,\n        merchant_context,\n        (payment_attempt.get_total_amount(), currency),\n        payment_intent,\n        payment_attempt,\n        refund,\n        split_refunds,\n        &merchant_connector_account,\n    )\n    .await?;\n\n    // Add access token for both UCS and direct connector paths\n    let add_access_token_result = Box::pin(access_token::add_access_token(\n        state,\n        &connector,\n        &router_data,\n        creds_identifier.as_deref(),\n    ))\n    .await?;\n\n    logger::debug!(refund_retrieve_router_data=?router_data);\n\n    access_token::update_router_data_with_access_token_result(\n        &add_access_token_result,\n        &mut router_data,\n        &payments::CallConnectorAction::Trigger,\n    );\n\n    // Common access token handling for all flows\n    let router_data_res = if !(add_access_token_result.connector_supports_access_token\n        && router_data.access_token.is_none())\n    {\n        // Access token available or not needed - proceed with execution\n\n        // Check which gateway system to use for refund sync\n        let (execution_path, _session_state) =\n            unified_connector_service::should_call_unified_connector_service(\n                state,\n                merchant_context,\n                &router_data,\n                None::<&payments::PaymentData<api::RSync>>, // No payment data for refunds\n                payments::CallConnectorAction::Trigger,\n            )\n            .await?;\n\n        router_env::logger::info!(\n            refund_id = router_data.request.refund_id,\n            execution_path = ?execution_path,\n            \"Executing refund sync via {execution_path:?}\"\n        );\n\n        // Execute refund sync based on gateway system decision\n        match execution_path {\n            common_enums::ExecutionPath::UnifiedConnectorService => {\n                unified_connector_service::call_unified_connector_service_for_refund_sync(\n                    state,\n                    merchant_context,\n                    router_data.clone(),\n                    ExecutionMode::Primary,\n                    merchant_connector_account,\n                )\n                .await\n                .attach_printable(format!(\n                    \"UCS refund sync failed for connector: {}, refund_id: {}\",\n                    connector.connector_name, router_data.request.refund_id\n                ))?\n            }\n            common_enums::ExecutionPath::Direct => {\n                Box::pin(execute_refund_sync_via_direct(\n                    state,\n                    &connector,\n                    router_data,\n                ))\n                .await?\n            }\n            common_enums::ExecutionPath::ShadowUnifiedConnectorService => {\n                Box::pin(execute_refund_sync_via_direct_with_ucs_shadow(\n                    state,\n                    &connector,\n                    merchant_context,\n                    router_data,\n                    merchant_connector_account,\n                ))\n                .await?\n            }\n        }\n    } else {\n        // Access token needed but not available - return error router_data\n        router_data\n    };\n\n    let refund_update = match router_data_res.response {\n        Err(error_message) => {\n            let refund_status = match error_message.status_code {\n                // marking failure for 2xx because this is genuine refund failure\n                200..=299 => Some(enums::RefundStatus::Failure),\n                _ => None,\n            };\n            diesel_refund::RefundUpdate::ErrorUpdate {\n                refund_status,\n                refund_error_message: error_message.reason.or(Some(error_message.message)),\n                refund_error_code: Some(error_message.code),\n                updated_by: storage_scheme.to_string(),\n                connector_refund_id: None,\n                processor_refund_data: None,\n                unified_code: None,\n                unified_message: None,\n                issuer_error_code: error_message.network_decline_code,\n                issuer_error_message: error_message.network_error_message,\n            }\n        }\n        Ok(response) => match router_data_res.integrity_check.clone() {\n            Err(err) => {\n                metrics::INTEGRITY_CHECK_FAILED.add(\n                    1,\n                    router_env::metric_attributes!(\n                        (\"connector\", connector.connector_name.to_string()),\n                        (\n                            \"merchant_id\",\n                            merchant_context.get_merchant_account().get_id().clone()\n                        ),\n                    ),\n                );\n                let (refund_connector_transaction_id, processor_refund_data) = err\n                    .connector_transaction_id\n                    .map_or((None, None), |refund_id| {\n                        let (refund_id, refund_data) =\n                            ConnectorTransactionId::form_id_and_data(refund_id);\n                        (Some(refund_id), refund_data)\n                    });\n                diesel_refund::RefundUpdate::ErrorUpdate {\n                    refund_status: Some(enums::RefundStatus::ManualReview),\n                    refund_error_message: Some(format!(\n                        \"Integrity Check Failed! as data mismatched for fields {}\",\n                        err.field_names\n                    )),\n                    refund_error_code: Some(\"IE\".to_string()),\n                    updated_by: storage_scheme.to_string(),\n                    connector_refund_id: refund_connector_transaction_id,\n                    processor_refund_data,\n                    unified_code: None,\n                    unified_message: None,\n                    issuer_error_code: None,\n                    issuer_error_message: None,\n                }\n            }\n            Ok(()) => {\n                let (connector_refund_id, processor_refund_data) =\n                    ConnectorTransactionId::form_id_and_data(response.connector_refund_id);\n                diesel_refund::RefundUpdate::Update {\n                    connector_refund_id,\n                    refund_status: response.refund_status,\n                    sent_to_gateway: true,\n                    refund_error_message: None,\n                    refund_arn: \"\".to_string(),\n                    updated_by: storage_scheme.to_string(),\n                    processor_refund_data,\n                }\n            }\n        },\n    };\n\n    let response = state\n        .store\n        .update_refund(\n            refund.to_owned(),\n            refund_update,\n            merchant_context.get_merchant_account().storage_scheme,\n        )\n        .await\n        .to_not_found_response(errors::ApiErrorResponse::RefundNotFound)\n        .attach_printable_lazy(|| {\n            format!(\n                \"Unable to update refund with refund_id: {}\",\n                refund.refund_id\n            )\n        })?;\n    utils::trigger_refund_outgoing_webhook(\n        state,\n        merchant_context,\n        &response,\n        payment_attempt.profile_id.clone(),\n    )\n    .await\n    .map_err(|error| logger::warn!(refunds_outgoing_webhook_error=?error))\n    .ok();\n    Ok(response)\n}",
+      "after_code": "pub async fn sync_refund_with_gateway(\n    state: &SessionState,\n    merchant_context: &domain::MerchantContext,\n    payment_attempt: &storage::PaymentAttempt,\n    payment_intent: &storage::PaymentIntent,\n    refund: &diesel_refund::Refund,\n    creds_identifier: Option<String>,\n    split_refunds: Option<SplitRefundsRequest>,\n) -> RouterResult<diesel_refund::Refund> {\n    let connector_id = refund.connector.to_string();\n    let connector: api::ConnectorData = api::ConnectorData::get_connector_by_name(\n        &state.conf.connectors,\n        &connector_id,\n        api::GetToken::Connector,\n        payment_attempt.merchant_connector_id.clone(),\n    )\n    .change_context(errors::ApiErrorResponse::InternalServerError)\n    .attach_printable(\"Failed to get the connector\")?;\n\n    let storage_scheme = merchant_context.get_merchant_account().storage_scheme;\n\n    let currency = payment_attempt.currency.get_required_value(\"currency\")?;\n\n    // Fetch merchant connector account\n    let profile_id = payment_intent\n        .profile_id\n        .as_ref()\n        .get_required_value(\"profile_id\")\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"profile_id is not set in payment_intent\")?;\n\n    let merchant_connector_account = helpers::get_merchant_connector_account(\n        state,\n        merchant_context.get_merchant_account().get_id(),\n        creds_identifier.as_deref(),\n        merchant_context.get_merchant_key_store(),\n        profile_id,\n        &connector_id,\n        payment_attempt.merchant_connector_id.as_ref(),\n    )\n    .await?;\n\n    let mut router_data = core_utils::construct_refund_router_data::<api::RSync>(\n        state,\n        &connector_id,\n        merchant_context,\n        (payment_attempt.get_total_amount(), currency),\n        payment_intent,\n        payment_attempt,\n        refund,\n        split_refunds,\n        &merchant_connector_account,\n    )\n    .await?;\n\n    // Add access token for both UCS and direct connector paths\n    let add_access_token_result = Box::pin(access_token::add_access_token(\n        state,\n        &connector,\n        &router_data,\n        creds_identifier.as_deref(),\n    ))\n    .await?;\n\n    logger::debug!(refund_retrieve_router_data=?router_data);\n\n    access_token::update_router_data_with_access_token_result(\n        &add_access_token_result,\n        &mut router_data,\n        &payments::CallConnectorAction::Trigger,\n    );\n\n    // Common access token handling for all flows\n    let router_data_res = if !(add_access_token_result.connector_supports_access_token\n        && router_data.access_token.is_none())\n    {\n        // Access token available or not needed - proceed with execution\n\n        // Check which gateway system to use for refund sync\n        let (execution_path, updated_state) =\n            unified_connector_service::should_call_unified_connector_service(\n                state,\n                merchant_context,\n                &router_data,\n                None::<&payments::PaymentData<api::RSync>>, // No payment data for refunds\n                payments::CallConnectorAction::Trigger,\n            )\n            .await?;\n\n        router_env::logger::info!(\n            refund_id = router_data.request.refund_id,\n            execution_path = ?execution_path,\n            \"Executing refund sync via {execution_path:?}\"\n        );\n\n        // Execute refund sync based on gateway system decision\n        match execution_path {\n            common_enums::ExecutionPath::UnifiedConnectorService => {\n                unified_connector_service::call_unified_connector_service_for_refund_sync(\n                    state,\n                    merchant_context,\n                    router_data.clone(),\n                    ExecutionMode::Primary,\n                    merchant_connector_account,\n                )\n                .await\n                .attach_printable(format!(\n                    \"UCS refund sync failed for connector: {}, refund_id: {}\",\n                    connector.connector_name, router_data.request.refund_id\n                ))?\n            }\n            common_enums::ExecutionPath::Direct => {\n                Box::pin(execute_refund_sync_via_direct(\n                    state,\n                    &connector,\n                    router_data,\n                ))\n                .await?\n            }\n            common_enums::ExecutionPath::ShadowUnifiedConnectorService => {\n                Box::pin(execute_refund_sync_via_direct_with_ucs_shadow(\n                    &updated_state,\n                    &connector,\n                    merchant_context,\n                    router_data,\n                    merchant_connector_account,\n                ))\n                .await?\n            }\n        }\n    } else {\n        // Access token needed but not available - return error router_data\n        router_data\n    };\n\n    let refund_update = match router_data_res.response {\n        Err(error_message) => {\n            let refund_status = match error_message.status_code {\n                // marking failure for 2xx because this is genuine refund failure\n                200..=299 => Some(enums::RefundStatus::Failure),\n                _ => None,\n            };\n            diesel_refund::RefundUpdate::ErrorUpdate {\n                refund_status,\n                refund_error_message: error_message.reason.or(Some(error_message.message)),\n                refund_error_code: Some(error_message.code),\n                updated_by: storage_scheme.to_string(),\n                connector_refund_id: None,\n                processor_refund_data: None,\n                unified_code: None,\n                unified_message: None,\n                issuer_error_code: error_message.network_decline_code,\n                issuer_error_message: error_message.network_error_message,\n            }\n        }\n        Ok(response) => match router_data_res.integrity_check.clone() {\n            Err(err) => {\n                metrics::INTEGRITY_CHECK_FAILED.add(\n                    1,\n                    router_env::metric_attributes!(\n                        (\"connector\", connector.connector_name.to_string()),\n                        (\n                            \"merchant_id\",\n                            merchant_context.get_merchant_account().get_id().clone()\n                        ),\n                    ),\n                );\n                let (refund_connector_transaction_id, processor_refund_data) = err\n                    .connector_transaction_id\n                    .map_or((None, None), |refund_id| {\n                        let (refund_id, refund_data) =\n                            ConnectorTransactionId::form_id_and_data(refund_id);\n                        (Some(refund_id), refund_data)\n                    });\n                diesel_refund::RefundUpdate::ErrorUpdate {\n                    refund_status: Some(enums::RefundStatus::ManualReview),\n                    refund_error_message: Some(format!(\n                        \"Integrity Check Failed! as data mismatched for fields {}\",\n                        err.field_names\n                    )),\n                    refund_error_code: Some(\"IE\".to_string()),\n                    updated_by: storage_scheme.to_string(),\n                    connector_refund_id: refund_connector_transaction_id,\n                    processor_refund_data,\n                    unified_code: None,\n                    unified_message: None,\n                    issuer_error_code: None,\n                    issuer_error_message: None,\n                }\n            }\n            Ok(()) => {\n                let (connector_refund_id, processor_refund_data) =\n                    ConnectorTransactionId::form_id_and_data(response.connector_refund_id);\n                diesel_refund::RefundUpdate::Update {\n                    connector_refund_id,\n                    refund_status: response.refund_status,\n                    sent_to_gateway: true,\n                    refund_error_message: None,\n                    refund_arn: \"\".to_string(),\n                    updated_by: storage_scheme.to_string(),\n                    processor_refund_data,\n                }\n            }\n        },\n    };\n\n    let response = state\n        .store\n        .update_refund(\n            refund.to_owned(),\n            refund_update,\n            merchant_context.get_merchant_account().storage_scheme,\n        )\n        .await\n        .to_not_found_response(errors::ApiErrorResponse::RefundNotFound)\n        .attach_printable_lazy(|| {\n            format!(\n                \"Unable to update refund with refund_id: {}\",\n                refund.refund_id\n            )\n        })?;\n    utils::trigger_refund_outgoing_webhook(\n        state,\n        merchant_context,\n        &response,\n        payment_attempt.profile_id.clone(),\n    )\n    .await\n    .map_err(|error| logger::warn!(refunds_outgoing_webhook_error=?error))\n    .ok();\n    Ok(response)\n}",
+      "diff_span": {
+        "before": "\n        // Check which gateway system to use for refund sync\n        let (execution_path, _session_state) =\n            unified_connector_service::should_call_unified_connector_service(\n                state,\n                merchant_context,\n                &router_data,\n                None::<&payments::PaymentData<api::RSync>>, // No payment data for refunds\n                payments::CallConnectorAction::Trigger,\n            )\n            .await?;\n\n        router_env::logger::info!(\n            refund_id = router_data.request.refund_id,\n            execution_path = ?execution_path,\n            \"Executing refund sync via {execution_path:?}\"\n        );\n\n        // Execute refund sync based on gateway system decision\n        match execution_path {\n            common_enums::ExecutionPath::UnifiedConnectorService => {\n                unified_connector_service::call_unified_connector_service_for_refund_sync(\n                    state,\n                    merchant_context,\n                    router_data.clone(),\n                    ExecutionMode::Primary,\n                    merchant_connector_account,\n                )\n                .await\n                .attach_printable(format!(\n                    \"UCS refund sync failed for connector: {}, refund_id: {}\",\n                    connector.connector_name, router_data.request.refund_id\n                ))?\n            }\n            common_enums::ExecutionPath::Direct => {\n                Box::pin(execute_refund_sync_via_direct(\n                    state,\n                    &connector,\n                    router_data,\n                ))\n                .await?\n            }\n            common_enums::ExecutionPath::ShadowUnifiedConnectorService => {\n                Box::pin(execute_refund_sync_via_direct_with_ucs_shadow(\n                    state,\n                    &connector,\n                    merchant_context,",
+        "after": "\n        // Check which gateway system to use for refund sync\n        let (execution_path, updated_state) =\n            unified_connector_service::should_call_unified_connector_service(\n                state,\n                merchant_context,\n                &router_data,\n                None::<&payments::PaymentData<api::RSync>>, // No payment data for refunds\n                payments::CallConnectorAction::Trigger,\n            )\n            .await?;\n\n        router_env::logger::info!(\n            refund_id = router_data.request.refund_id,\n            execution_path = ?execution_path,\n            \"Executing refund sync via {execution_path:?}\"\n        );\n\n        // Execute refund sync based on gateway system decision\n        match execution_path {\n            common_enums::ExecutionPath::UnifiedConnectorService => {\n                unified_connector_service::call_unified_connector_service_for_refund_sync(\n                    state,\n                    merchant_context,\n                    router_data.clone(),\n                    ExecutionMode::Primary,\n                    merchant_connector_account,\n                )\n                .await\n                .attach_printable(format!(\n                    \"UCS refund sync failed for connector: {}, refund_id: {}\",\n                    connector.connector_name, router_data.request.refund_id\n                ))?\n            }\n            common_enums::ExecutionPath::Direct => {\n                Box::pin(execute_refund_sync_via_direct(\n                    state,\n                    &connector,\n                    router_data,\n                ))\n                .await?\n            }\n            common_enums::ExecutionPath::ShadowUnifiedConnectorService => {\n                Box::pin(execute_refund_sync_via_direct_with_ucs_shadow(\n                    &updated_state,\n                    &connector,\n                    merchant_context,"
+      },
+      "commit_sha": "b7bcc6bf9e9eba706f12ecedaf11ec4b9997f2cc"
+    },
+    {
+      "id": "crates/router/src/core/refunds.rs::function::trigger_refund_to_gateway",
+      "file": "crates/router/src/core/refunds.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn trigger_refund_to_gateway(\n    state: &SessionState,\n    refund: &diesel_refund::Refund,\n    merchant_context: &domain::MerchantContext,\n    payment_attempt: &storage::PaymentAttempt,\n    payment_intent: &storage::PaymentIntent,\n    creds_identifier: Option<String>,\n    split_refunds: Option<SplitRefundsRequest>,\n) -> RouterResult<diesel_refund::Refund> {\n    let routed_through = payment_attempt\n        .connector\n        .clone()\n        .ok_or(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Failed to retrieve connector from payment attempt\")?;\n\n    let storage_scheme = merchant_context.get_merchant_account().storage_scheme;\n    metrics::REFUND_COUNT.add(\n        1,\n        router_env::metric_attributes!((\"connector\", routed_through.clone())),\n    );\n\n    let connector: api::ConnectorData = api::ConnectorData::get_connector_by_name(\n        &state.conf.connectors,\n        &routed_through,\n        api::GetToken::Connector,\n        payment_attempt.merchant_connector_id.clone(),\n    )?;\n\n    let currency = payment_attempt.currency.ok_or_else(|| {\n        report!(errors::ApiErrorResponse::InternalServerError).attach_printable(\n            \"Transaction in invalid. Missing field \\\"currency\\\" in payment_attempt.\",\n        )\n    })?;\n\n    validator::validate_for_valid_refunds(payment_attempt, connector.connector_name)?;\n\n    // Fetch merchant connector account\n    let profile_id = payment_intent\n        .profile_id\n        .as_ref()\n        .get_required_value(\"profile_id\")\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"profile_id is not set in payment_intent\")?;\n\n    let merchant_connector_account = helpers::get_merchant_connector_account(\n        state,\n        merchant_context.get_merchant_account().get_id(),\n        creds_identifier.as_deref(),\n        merchant_context.get_merchant_key_store(),\n        profile_id,\n        &routed_through,\n        payment_attempt.merchant_connector_id.as_ref(),\n    )\n    .await?;\n\n    let mut router_data = core_utils::construct_refund_router_data(\n        state,\n        &routed_through,\n        merchant_context,\n        (payment_attempt.get_total_amount(), currency),\n        payment_intent,\n        payment_attempt,\n        refund,\n        split_refunds,\n        &merchant_connector_account,\n    )\n    .await?;\n\n    // Add access token for both UCS and direct connector paths\n    let add_access_token_result = Box::pin(access_token::add_access_token(\n        state,\n        &connector,\n        &router_data,\n        creds_identifier.as_deref(),\n    ))\n    .await?;\n\n    logger::debug!(refund_router_data=?router_data);\n\n    access_token::update_router_data_with_access_token_result(\n        &add_access_token_result,\n        &mut router_data,\n        &payments::CallConnectorAction::Trigger,\n    );\n\n    // Common access token handling for all flows\n    let router_data_res = if !(add_access_token_result.connector_supports_access_token\n        && router_data.access_token.is_none())\n    {\n        // Access token available or not needed - proceed with execution\n\n        // Check which gateway system to use for refunds\n        let (execution_path, _session_state) =\n            unified_connector_service::should_call_unified_connector_service(\n                state,\n                merchant_context,\n                &router_data,\n                None::<&payments::PaymentData<api::Execute>>, // No payment data for refunds\n                payments::CallConnectorAction::Trigger,\n            )\n            .await?;\n\n        router_env::logger::info!(\n            refund_id = refund.refund_id,\n            execution_path = ?execution_path,\n            \"Executing refund via {execution_path:?}\"\n        );\n\n        // Execute refund based on gateway system decision\n        match execution_path {\n            common_enums::ExecutionPath::UnifiedConnectorService => {\n                unified_connector_service::call_unified_connector_service_for_refund_execute(\n                    state,\n                    merchant_context,\n                    router_data.clone(),\n                    ExecutionMode::Primary,\n                    merchant_connector_account,\n                )\n                .await\n                .attach_printable(format!(\n                    \"UCS refund execution failed for connector: {}, refund_id: {}\",\n                    connector.connector_name, router_data.request.refund_id\n                ))?\n            }\n            common_enums::ExecutionPath::Direct => {\n                Box::pin(execute_refund_execute_via_direct(\n                    state,\n                    &connector,\n                    merchant_context,\n                    refund,\n                    router_data,\n                ))\n                .await?\n            }\n            common_enums::ExecutionPath::ShadowUnifiedConnectorService => {\n                Box::pin(execute_refund_execute_via_direct_with_ucs_shadow(\n                    state,\n                    &connector,\n                    merchant_context,\n                    refund,\n                    router_data,\n                    merchant_connector_account.clone(),\n                ))\n                .await?\n            }\n        }\n    } else {\n        // Access token needed but not available - return error router_data\n        router_data\n    };\n\n    let refund_update = match router_data_res.response {\n        Err(err) => {\n            let option_gsm = helpers::get_gsm_record(\n                state,\n                Some(err.code.clone()),\n                Some(err.message.clone()),\n                connector.connector_name.to_string(),\n                consts::REFUND_FLOW_STR.to_string(),\n            )\n            .await;\n            // Note: Some connectors do not have a separate list of refund errors\n            // In such cases, the error codes and messages are stored under \"Authorize\" flow in GSM table\n            // So we will have to fetch the GSM using Authorize flow in case GSM is not found using \"refund_flow\"\n            let option_gsm = if option_gsm.is_none() {\n                helpers::get_gsm_record(\n                    state,\n                    Some(err.code.clone()),\n                    Some(err.message.clone()),\n                    connector.connector_name.to_string(),\n                    consts::AUTHORIZE_FLOW_STR.to_string(),\n                )\n                .await\n            } else {\n                option_gsm\n            };\n\n            let gsm_unified_code = option_gsm.as_ref().and_then(|gsm| gsm.unified_code.clone());\n            let gsm_unified_message = option_gsm.and_then(|gsm| gsm.unified_message);\n\n            let (unified_code, unified_message) = if let Some((code, message)) =\n                gsm_unified_code.as_ref().zip(gsm_unified_message.as_ref())\n            {\n                (code.to_owned(), message.to_owned())\n            } else {\n                (\n                    consts::DEFAULT_UNIFIED_ERROR_CODE.to_owned(),\n                    consts::DEFAULT_UNIFIED_ERROR_MESSAGE.to_owned(),\n                )\n            };\n\n            diesel_refund::RefundUpdate::ErrorUpdate {\n                refund_status: Some(enums::RefundStatus::Failure),\n                refund_error_message: err.reason.or(Some(err.message)),\n                refund_error_code: Some(err.code),\n                updated_by: storage_scheme.to_string(),\n                connector_refund_id: None,\n                processor_refund_data: None,\n                unified_code: Some(unified_code),\n                unified_message: Some(unified_message),\n                issuer_error_code: err.network_decline_code,\n                issuer_error_message: err.network_error_message,\n            }\n        }\n        Ok(response) => {\n            // match on connector integrity checks\n            match router_data_res.integrity_check.clone() {\n                Err(err) => {\n                    let (refund_connector_transaction_id, processor_refund_data) =\n                        err.connector_transaction_id.map_or((None, None), |txn_id| {\n                            let (refund_id, refund_data) =\n                                ConnectorTransactionId::form_id_and_data(txn_id);\n                            (Some(refund_id), refund_data)\n                        });\n                    metrics::INTEGRITY_CHECK_FAILED.add(\n                        1,\n                        router_env::metric_attributes!(\n                            (\"connector\", connector.connector_name.to_string()),\n                            (\n                                \"merchant_id\",\n                                merchant_context.get_merchant_account().get_id().clone()\n                            ),\n                        ),\n                    );\n                    diesel_refund::RefundUpdate::ErrorUpdate {\n                        refund_status: Some(enums::RefundStatus::ManualReview),\n                        refund_error_message: Some(format!(\n                            \"Integrity Check Failed! as data mismatched for fields {}\",\n                            err.field_names\n                        )),\n                        refund_error_code: Some(\"IE\".to_string()),\n                        updated_by: storage_scheme.to_string(),\n                        connector_refund_id: refund_connector_transaction_id,\n                        processor_refund_data,\n                        unified_code: None,\n                        unified_message: None,\n                        issuer_error_code: None,\n                        issuer_error_message: None,\n                    }\n                }\n                Ok(()) => {\n                    if response.refund_status == diesel_models::enums::RefundStatus::Success {\n                        metrics::SUCCESSFUL_REFUND.add(\n                            1,\n                            router_env::metric_attributes!((\n                                \"connector\",\n                                connector.connector_name.to_string(),\n                            )),\n                        )\n                    }\n                    let (connector_refund_id, processor_refund_data) =\n                        ConnectorTransactionId::form_id_and_data(response.connector_refund_id);\n                    diesel_refund::RefundUpdate::Update {\n                        connector_refund_id,\n                        refund_status: response.refund_status,\n                        sent_to_gateway: true,\n                        refund_error_message: None,\n                        refund_arn: \"\".to_string(),\n                        updated_by: storage_scheme.to_string(),\n                        processor_refund_data,\n                    }\n                }\n            }\n        }\n    };\n\n    let response = state\n        .store\n        .update_refund(\n            refund.to_owned(),\n            refund_update,\n            merchant_context.get_merchant_account().storage_scheme,\n        )\n        .await\n        .to_not_found_response(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable_lazy(|| {\n            format!(\n                \"Failed while updating refund: refund_id: {}\",\n                refund.refund_id\n            )\n        })?;\n    utils::trigger_refund_outgoing_webhook(\n        state,\n        merchant_context,\n        &response,\n        payment_attempt.profile_id.clone(),\n    )\n    .await\n    .map_err(|error| logger::warn!(refunds_outgoing_webhook_error=?error))\n    .ok();\n    Ok(response)\n}",
+      "after_code": "pub async fn trigger_refund_to_gateway(\n    state: &SessionState,\n    refund: &diesel_refund::Refund,\n    merchant_context: &domain::MerchantContext,\n    payment_attempt: &storage::PaymentAttempt,\n    payment_intent: &storage::PaymentIntent,\n    creds_identifier: Option<String>,\n    split_refunds: Option<SplitRefundsRequest>,\n) -> RouterResult<diesel_refund::Refund> {\n    let routed_through = payment_attempt\n        .connector\n        .clone()\n        .ok_or(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Failed to retrieve connector from payment attempt\")?;\n\n    let storage_scheme = merchant_context.get_merchant_account().storage_scheme;\n    metrics::REFUND_COUNT.add(\n        1,\n        router_env::metric_attributes!((\"connector\", routed_through.clone())),\n    );\n\n    let connector: api::ConnectorData = api::ConnectorData::get_connector_by_name(\n        &state.conf.connectors,\n        &routed_through,\n        api::GetToken::Connector,\n        payment_attempt.merchant_connector_id.clone(),\n    )?;\n\n    let currency = payment_attempt.currency.ok_or_else(|| {\n        report!(errors::ApiErrorResponse::InternalServerError).attach_printable(\n            \"Transaction in invalid. Missing field \\\"currency\\\" in payment_attempt.\",\n        )\n    })?;\n\n    validator::validate_for_valid_refunds(payment_attempt, connector.connector_name)?;\n\n    // Fetch merchant connector account\n    let profile_id = payment_intent\n        .profile_id\n        .as_ref()\n        .get_required_value(\"profile_id\")\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"profile_id is not set in payment_intent\")?;\n\n    let merchant_connector_account = helpers::get_merchant_connector_account(\n        state,\n        merchant_context.get_merchant_account().get_id(),\n        creds_identifier.as_deref(),\n        merchant_context.get_merchant_key_store(),\n        profile_id,\n        &routed_through,\n        payment_attempt.merchant_connector_id.as_ref(),\n    )\n    .await?;\n\n    let mut router_data = core_utils::construct_refund_router_data(\n        state,\n        &routed_through,\n        merchant_context,\n        (payment_attempt.get_total_amount(), currency),\n        payment_intent,\n        payment_attempt,\n        refund,\n        split_refunds,\n        &merchant_connector_account,\n    )\n    .await?;\n\n    // Add access token for both UCS and direct connector paths\n    let add_access_token_result = Box::pin(access_token::add_access_token(\n        state,\n        &connector,\n        &router_data,\n        creds_identifier.as_deref(),\n    ))\n    .await?;\n\n    logger::debug!(refund_router_data=?router_data);\n\n    access_token::update_router_data_with_access_token_result(\n        &add_access_token_result,\n        &mut router_data,\n        &payments::CallConnectorAction::Trigger,\n    );\n\n    // Common access token handling for all flows\n    let router_data_res = if !(add_access_token_result.connector_supports_access_token\n        && router_data.access_token.is_none())\n    {\n        // Access token available or not needed - proceed with execution\n\n        // Check which gateway system to use for refunds\n        let (execution_path, updated_state) =\n            unified_connector_service::should_call_unified_connector_service(\n                state,\n                merchant_context,\n                &router_data,\n                None::<&payments::PaymentData<api::Execute>>, // No payment data for refunds\n                payments::CallConnectorAction::Trigger,\n            )\n            .await?;\n\n        router_env::logger::info!(\n            refund_id = refund.refund_id,\n            execution_path = ?execution_path,\n            \"Executing refund via {execution_path:?}\"\n        );\n\n        // Execute refund based on gateway system decision\n        match execution_path {\n            common_enums::ExecutionPath::UnifiedConnectorService => {\n                unified_connector_service::call_unified_connector_service_for_refund_execute(\n                    state,\n                    merchant_context,\n                    router_data.clone(),\n                    ExecutionMode::Primary,\n                    merchant_connector_account,\n                )\n                .await\n                .attach_printable(format!(\n                    \"UCS refund execution failed for connector: {}, refund_id: {}\",\n                    connector.connector_name, router_data.request.refund_id\n                ))?\n            }\n            common_enums::ExecutionPath::Direct => {\n                Box::pin(execute_refund_execute_via_direct(\n                    state,\n                    &connector,\n                    merchant_context,\n                    refund,\n                    router_data,\n                ))\n                .await?\n            }\n            common_enums::ExecutionPath::ShadowUnifiedConnectorService => {\n                Box::pin(execute_refund_execute_via_direct_with_ucs_shadow(\n                    &updated_state,\n                    &connector,\n                    merchant_context,\n                    refund,\n                    router_data,\n                    merchant_connector_account.clone(),\n                ))\n                .await?\n            }\n        }\n    } else {\n        // Access token needed but not available - return error router_data\n        router_data\n    };\n\n    let refund_update = match router_data_res.response {\n        Err(err) => {\n            let option_gsm = helpers::get_gsm_record(\n                state,\n                Some(err.code.clone()),\n                Some(err.message.clone()),\n                connector.connector_name.to_string(),\n                consts::REFUND_FLOW_STR.to_string(),\n            )\n            .await;\n            // Note: Some connectors do not have a separate list of refund errors\n            // In such cases, the error codes and messages are stored under \"Authorize\" flow in GSM table\n            // So we will have to fetch the GSM using Authorize flow in case GSM is not found using \"refund_flow\"\n            let option_gsm = if option_gsm.is_none() {\n                helpers::get_gsm_record(\n                    state,\n                    Some(err.code.clone()),\n                    Some(err.message.clone()),\n                    connector.connector_name.to_string(),\n                    consts::AUTHORIZE_FLOW_STR.to_string(),\n                )\n                .await\n            } else {\n                option_gsm\n            };\n\n            let gsm_unified_code = option_gsm.as_ref().and_then(|gsm| gsm.unified_code.clone());\n            let gsm_unified_message = option_gsm.and_then(|gsm| gsm.unified_message);\n\n            let (unified_code, unified_message) = if let Some((code, message)) =\n                gsm_unified_code.as_ref().zip(gsm_unified_message.as_ref())\n            {\n                (code.to_owned(), message.to_owned())\n            } else {\n                (\n                    consts::DEFAULT_UNIFIED_ERROR_CODE.to_owned(),\n                    consts::DEFAULT_UNIFIED_ERROR_MESSAGE.to_owned(),\n                )\n            };\n\n            diesel_refund::RefundUpdate::ErrorUpdate {\n                refund_status: Some(enums::RefundStatus::Failure),\n                refund_error_message: err.reason.or(Some(err.message)),\n                refund_error_code: Some(err.code),\n                updated_by: storage_scheme.to_string(),\n                connector_refund_id: None,\n                processor_refund_data: None,\n                unified_code: Some(unified_code),\n                unified_message: Some(unified_message),\n                issuer_error_code: err.network_decline_code,\n                issuer_error_message: err.network_error_message,\n            }\n        }\n        Ok(response) => {\n            // match on connector integrity checks\n            match router_data_res.integrity_check.clone() {\n                Err(err) => {\n                    let (refund_connector_transaction_id, processor_refund_data) =\n                        err.connector_transaction_id.map_or((None, None), |txn_id| {\n                            let (refund_id, refund_data) =\n                                ConnectorTransactionId::form_id_and_data(txn_id);\n                            (Some(refund_id), refund_data)\n                        });\n                    metrics::INTEGRITY_CHECK_FAILED.add(\n                        1,\n                        router_env::metric_attributes!(\n                            (\"connector\", connector.connector_name.to_string()),\n                            (\n                                \"merchant_id\",\n                                merchant_context.get_merchant_account().get_id().clone()\n                            ),\n                        ),\n                    );\n                    diesel_refund::RefundUpdate::ErrorUpdate {\n                        refund_status: Some(enums::RefundStatus::ManualReview),\n                        refund_error_message: Some(format!(\n                            \"Integrity Check Failed! as data mismatched for fields {}\",\n                            err.field_names\n                        )),\n                        refund_error_code: Some(\"IE\".to_string()),\n                        updated_by: storage_scheme.to_string(),\n                        connector_refund_id: refund_connector_transaction_id,\n                        processor_refund_data,\n                        unified_code: None,\n                        unified_message: None,\n                        issuer_error_code: None,\n                        issuer_error_message: None,\n                    }\n                }\n                Ok(()) => {\n                    if response.refund_status == diesel_models::enums::RefundStatus::Success {\n                        metrics::SUCCESSFUL_REFUND.add(\n                            1,\n                            router_env::metric_attributes!((\n                                \"connector\",\n                                connector.connector_name.to_string(),\n                            )),\n                        )\n                    }\n                    let (connector_refund_id, processor_refund_data) =\n                        ConnectorTransactionId::form_id_and_data(response.connector_refund_id);\n                    diesel_refund::RefundUpdate::Update {\n                        connector_refund_id,\n                        refund_status: response.refund_status,\n                        sent_to_gateway: true,\n                        refund_error_message: None,\n                        refund_arn: \"\".to_string(),\n                        updated_by: storage_scheme.to_string(),\n                        processor_refund_data,\n                    }\n                }\n            }\n        }\n    };\n\n    let response = state\n        .store\n        .update_refund(\n            refund.to_owned(),\n            refund_update,\n            merchant_context.get_merchant_account().storage_scheme,\n        )\n        .await\n        .to_not_found_response(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable_lazy(|| {\n            format!(\n                \"Failed while updating refund: refund_id: {}\",\n                refund.refund_id\n            )\n        })?;\n    utils::trigger_refund_outgoing_webhook(\n        state,\n        merchant_context,\n        &response,\n        payment_attempt.profile_id.clone(),\n    )\n    .await\n    .map_err(|error| logger::warn!(refunds_outgoing_webhook_error=?error))\n    .ok();\n    Ok(response)\n}",
+      "diff_span": {
+        "before": "\n        // Check which gateway system to use for refunds\n        let (execution_path, _session_state) =\n            unified_connector_service::should_call_unified_connector_service(\n                state,\n                merchant_context,\n                &router_data,\n                None::<&payments::PaymentData<api::Execute>>, // No payment data for refunds\n                payments::CallConnectorAction::Trigger,\n            )\n            .await?;\n\n        router_env::logger::info!(\n            refund_id = refund.refund_id,\n            execution_path = ?execution_path,\n            \"Executing refund via {execution_path:?}\"\n        );\n\n        // Execute refund based on gateway system decision\n        match execution_path {\n            common_enums::ExecutionPath::UnifiedConnectorService => {\n                unified_connector_service::call_unified_connector_service_for_refund_execute(\n                    state,\n                    merchant_context,\n                    router_data.clone(),\n                    ExecutionMode::Primary,\n                    merchant_connector_account,\n                )\n                .await\n                .attach_printable(format!(\n                    \"UCS refund execution failed for connector: {}, refund_id: {}\",\n                    connector.connector_name, router_data.request.refund_id\n                ))?\n            }\n            common_enums::ExecutionPath::Direct => {\n                Box::pin(execute_refund_execute_via_direct(\n                    state,\n                    &connector,\n                    merchant_context,\n                    refund,\n                    router_data,\n                ))\n                .await?\n            }\n            common_enums::ExecutionPath::ShadowUnifiedConnectorService => {\n                Box::pin(execute_refund_execute_via_direct_with_ucs_shadow(\n                    state,\n                    &connector,\n                    merchant_context,",
+        "after": "\n        // Check which gateway system to use for refunds\n        let (execution_path, updated_state) =\n            unified_connector_service::should_call_unified_connector_service(\n                state,\n                merchant_context,\n                &router_data,\n                None::<&payments::PaymentData<api::Execute>>, // No payment data for refunds\n                payments::CallConnectorAction::Trigger,\n            )\n            .await?;\n\n        router_env::logger::info!(\n            refund_id = refund.refund_id,\n            execution_path = ?execution_path,\n            \"Executing refund via {execution_path:?}\"\n        );\n\n        // Execute refund based on gateway system decision\n        match execution_path {\n            common_enums::ExecutionPath::UnifiedConnectorService => {\n                unified_connector_service::call_unified_connector_service_for_refund_execute(\n                    state,\n                    merchant_context,\n                    router_data.clone(),\n                    ExecutionMode::Primary,\n                    merchant_connector_account,\n                )\n                .await\n                .attach_printable(format!(\n                    \"UCS refund execution failed for connector: {}, refund_id: {}\",\n                    connector.connector_name, router_data.request.refund_id\n                ))?\n            }\n            common_enums::ExecutionPath::Direct => {\n                Box::pin(execute_refund_execute_via_direct(\n                    state,\n                    &connector,\n                    merchant_context,\n                    refund,\n                    router_data,\n                ))\n                .await?\n            }\n            common_enums::ExecutionPath::ShadowUnifiedConnectorService => {\n                Box::pin(execute_refund_execute_via_direct_with_ucs_shadow(\n                    &updated_state,\n                    &connector,\n                    merchant_context,"
+      },
+      "commit_sha": "b7bcc6bf9e9eba706f12ecedaf11ec4b9997f2cc"
+    }
+  ]
+}

diffs/pr_10119/e3a6ab8/diff.json

@@ -0,0 +1,39 @@
+{
+  "commit_sha": "e3a6ab841b3f5efc8183336ca73c62b3263a4de6",
+  "pr_number": 10119,
+  "rust_files": [
+    "crates/hyperswitch_connectors/src/connectors/stripe/transformers.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/stripe/transformers.rs::SetupIntentRequest::function::try_from",
+      "file": "crates/hyperswitch_connectors/src/connectors/stripe/transformers.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn try_from(item: &SetupMandateRouterData) -> Result<Self, Self::Error> {\n        //Only cards supported for mandates\n        let pm_type = StripePaymentMethodType::Card;\n        let payment_data = StripePaymentMethodData::try_from((item, item.auth_type, pm_type))?;\n\n        let meta_data = Some(get_transaction_metadata(\n            item.request.metadata.clone(),\n            item.connector_request_reference_id.clone(),\n        ));\n\n        let browser_info = item\n            .request\n            .browser_info\n            .clone()\n            .map(StripeBrowserInformation::from);\n\n        let is_moto = item.request.payment_channel == Some(common_enums::PaymentChannel::MailOrder)\n            || item.request.payment_channel == Some(common_enums::PaymentChannel::TelephoneOrder);\n\n        let setup_future_usage = match (item.request.setup_future_usage, is_moto) {\n            (Some(enums::FutureUsage::OnSession), true) => None,\n            _ => item.request.setup_future_usage,\n        };\n\n        Ok(Self {\n            confirm: true,\n            payment_data,\n            return_url: item.request.router_return_url.clone(),\n            off_session: item.request.off_session,\n            usage: setup_future_usage,\n            payment_method_options: None,\n            customer: item.connector_customer.to_owned().map(Secret::new),\n            meta_data,\n            payment_method_types: Some(pm_type),\n            expand: Some(ExpandableObjects::LatestAttempt),\n            browser_info,\n            moto: Some(is_moto),\n        })\n    }",
+      "after_code": "fn try_from(item: &SetupMandateRouterData) -> Result<Self, Self::Error> {\n        //Only cards supported for mandates\n        let pm_type = StripePaymentMethodType::Card;\n        let payment_data = StripePaymentMethodData::try_from((item, item.auth_type, pm_type))?;\n\n        let meta_data = Some(get_transaction_metadata(\n            item.request.metadata.clone(),\n            item.connector_request_reference_id.clone(),\n        ));\n\n        let browser_info = item\n            .request\n            .browser_info\n            .clone()\n            .map(StripeBrowserInformation::from);\n\n        let is_moto = if matches!(\n            item.request.payment_method_data,\n            PaymentMethodData::Card { .. }\n        ) && item.request.payment_channel\n            == Some(common_enums::PaymentChannel::MailOrder)\n            || item.request.payment_channel == Some(common_enums::PaymentChannel::TelephoneOrder)\n        {\n            Some(true)\n        } else {\n            None\n        };\n\n        let setup_future_usage = match (item.request.setup_future_usage, is_moto) {\n            (Some(enums::FutureUsage::OnSession), Some(true)) => None,\n            _ => item.request.setup_future_usage,\n        };\n\n        Ok(Self {\n            confirm: true,\n            payment_data,\n            return_url: item.request.router_return_url.clone(),\n            off_session: item.request.off_session,\n            usage: setup_future_usage,\n            payment_method_options: None,\n            customer: item.connector_customer.to_owned().map(Secret::new),\n            meta_data,\n            payment_method_types: Some(pm_type),\n            expand: Some(ExpandableObjects::LatestAttempt),\n            browser_info,\n            moto: is_moto,\n        })\n    }",
+      "diff_span": {
+        "before": "            .map(StripeBrowserInformation::from);\n\n        let is_moto = item.request.payment_channel == Some(common_enums::PaymentChannel::MailOrder)\n            || item.request.payment_channel == Some(common_enums::PaymentChannel::TelephoneOrder);\n\n        let setup_future_usage = match (item.request.setup_future_usage, is_moto) {\n            (Some(enums::FutureUsage::OnSession), true) => None,\n            _ => item.request.setup_future_usage,\n        };\n\n        Ok(Self {\n            confirm: true,\n            payment_data,\n            return_url: item.request.router_return_url.clone(),\n            off_session: item.request.off_session,\n            usage: setup_future_usage,\n            payment_method_options: None,\n            customer: item.connector_customer.to_owned().map(Secret::new),\n            meta_data,\n            payment_method_types: Some(pm_type),\n            expand: Some(ExpandableObjects::LatestAttempt),\n            browser_info,\n            moto: Some(is_moto),\n        })\n    }",
+        "after": "            .map(StripeBrowserInformation::from);\n\n        let is_moto = if matches!(\n            item.request.payment_method_data,\n            PaymentMethodData::Card { .. }\n        ) && item.request.payment_channel\n            == Some(common_enums::PaymentChannel::MailOrder)\n            || item.request.payment_channel == Some(common_enums::PaymentChannel::TelephoneOrder)\n        {\n            Some(true)\n        } else {\n            None\n        };\n\n        let setup_future_usage = match (item.request.setup_future_usage, is_moto) {\n            (Some(enums::FutureUsage::OnSession), Some(true)) => None,\n            _ => item.request.setup_future_usage,\n        };\n\n        Ok(Self {\n            confirm: true,\n            payment_data,\n            return_url: item.request.router_return_url.clone(),\n            off_session: item.request.off_session,\n            usage: setup_future_usage,\n            payment_method_options: None,\n            customer: item.connector_customer.to_owned().map(Secret::new),\n            meta_data,\n            payment_method_types: Some(pm_type),\n            expand: Some(ExpandableObjects::LatestAttempt),\n            browser_info,\n            moto: is_moto,\n        })\n    }"
+      },
+      "commit_sha": "e3a6ab841b3f5efc8183336ca73c62b3263a4de6"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/stripe/transformers.rs::impl::SetupIntentRequest",
+      "file": "crates/hyperswitch_connectors/src/connectors/stripe/transformers.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl TryFrom<&SetupMandateRouterData> for SetupIntentRequest {\n    type Error = error_stack::Report<ConnectorError>;\n    fn try_from(item: &SetupMandateRouterData) -> Result<Self, Self::Error> {\n        //Only cards supported for mandates\n        let pm_type = StripePaymentMethodType::Card;\n        let payment_data = StripePaymentMethodData::try_from((item, item.auth_type, pm_type))?;\n\n        let meta_data = Some(get_transaction_metadata(\n            item.request.metadata.clone(),\n            item.connector_request_reference_id.clone(),\n        ));\n\n        let browser_info = item\n            .request\n            .browser_info\n            .clone()\n            .map(StripeBrowserInformation::from);\n\n        let is_moto = item.request.payment_channel == Some(common_enums::PaymentChannel::MailOrder)\n            || item.request.payment_channel == Some(common_enums::PaymentChannel::TelephoneOrder);\n\n        let setup_future_usage = match (item.request.setup_future_usage, is_moto) {\n            (Some(enums::FutureUsage::OnSession), true) => None,\n            _ => item.request.setup_future_usage,\n        };\n\n        Ok(Self {\n            confirm: true,\n            payment_data,\n            return_url: item.request.router_return_url.clone(),\n            off_session: item.request.off_session,\n            usage: setup_future_usage,\n            payment_method_options: None,\n            customer: item.connector_customer.to_owned().map(Secret::new),\n            meta_data,\n            payment_method_types: Some(pm_type),\n            expand: Some(ExpandableObjects::LatestAttempt),\n            browser_info,\n            moto: Some(is_moto),\n        })\n    }\n}",
+      "after_code": "impl TryFrom<&SetupMandateRouterData> for SetupIntentRequest {\n    type Error = error_stack::Report<ConnectorError>;\n    fn try_from(item: &SetupMandateRouterData) -> Result<Self, Self::Error> {\n        //Only cards supported for mandates\n        let pm_type = StripePaymentMethodType::Card;\n        let payment_data = StripePaymentMethodData::try_from((item, item.auth_type, pm_type))?;\n\n        let meta_data = Some(get_transaction_metadata(\n            item.request.metadata.clone(),\n            item.connector_request_reference_id.clone(),\n        ));\n\n        let browser_info = item\n            .request\n            .browser_info\n            .clone()\n            .map(StripeBrowserInformation::from);\n\n        let is_moto = if matches!(\n            item.request.payment_method_data,\n            PaymentMethodData::Card { .. }\n        ) && item.request.payment_channel\n            == Some(common_enums::PaymentChannel::MailOrder)\n            || item.request.payment_channel == Some(common_enums::PaymentChannel::TelephoneOrder)\n        {\n            Some(true)\n        } else {\n            None\n        };\n\n        let setup_future_usage = match (item.request.setup_future_usage, is_moto) {\n            (Some(enums::FutureUsage::OnSession), Some(true)) => None,\n            _ => item.request.setup_future_usage,\n        };\n\n        Ok(Self {\n            confirm: true,\n            payment_data,\n            return_url: item.request.router_return_url.clone(),\n            off_session: item.request.off_session,\n            usage: setup_future_usage,\n            payment_method_options: None,\n            customer: item.connector_customer.to_owned().map(Secret::new),\n            meta_data,\n            payment_method_types: Some(pm_type),\n            expand: Some(ExpandableObjects::LatestAttempt),\n            browser_info,\n            moto: is_moto,\n        })\n    }\n}",
+      "diff_span": {
+        "before": "            .map(StripeBrowserInformation::from);\n\n        let is_moto = item.request.payment_channel == Some(common_enums::PaymentChannel::MailOrder)\n            || item.request.payment_channel == Some(common_enums::PaymentChannel::TelephoneOrder);\n\n        let setup_future_usage = match (item.request.setup_future_usage, is_moto) {\n            (Some(enums::FutureUsage::OnSession), true) => None,\n            _ => item.request.setup_future_usage,\n        };\n\n        Ok(Self {\n            confirm: true,\n            payment_data,\n            return_url: item.request.router_return_url.clone(),\n            off_session: item.request.off_session,\n            usage: setup_future_usage,\n            payment_method_options: None,\n            customer: item.connector_customer.to_owned().map(Secret::new),\n            meta_data,\n            payment_method_types: Some(pm_type),\n            expand: Some(ExpandableObjects::LatestAttempt),\n            browser_info,\n            moto: Some(is_moto),\n        })\n    }",
+        "after": "            .map(StripeBrowserInformation::from);\n\n        let is_moto = if matches!(\n            item.request.payment_method_data,\n            PaymentMethodData::Card { .. }\n        ) && item.request.payment_channel\n            == Some(common_enums::PaymentChannel::MailOrder)\n            || item.request.payment_channel == Some(common_enums::PaymentChannel::TelephoneOrder)\n        {\n            Some(true)\n        } else {\n            None\n        };\n\n        let setup_future_usage = match (item.request.setup_future_usage, is_moto) {\n            (Some(enums::FutureUsage::OnSession), Some(true)) => None,\n            _ => item.request.setup_future_usage,\n        };\n\n        Ok(Self {\n            confirm: true,\n            payment_data,\n            return_url: item.request.router_return_url.clone(),\n            off_session: item.request.off_session,\n            usage: setup_future_usage,\n            payment_method_options: None,\n            customer: item.connector_customer.to_owned().map(Secret::new),\n            meta_data,\n            payment_method_types: Some(pm_type),\n            expand: Some(ExpandableObjects::LatestAttempt),\n            browser_info,\n            moto: is_moto,\n        })\n    }"
+      },
+      "commit_sha": "e3a6ab841b3f5efc8183336ca73c62b3263a4de6"
+    }
+  ]
+}

diffs/pr_10124/1e962ad/diff.json

@@ -0,0 +1,6 @@
+{
+  "commit_sha": "1e962adb2884fca759f4bab0ece664900a0986b1",
+  "pr_number": 10124,
+  "rust_files": [],
+  "diffs": []
+}

diffs/pr_10124/5a1e03b/diff.json

@@ -0,0 +1,6 @@
+{
+  "commit_sha": "5a1e03b1035e48294619d08e91280a29746ff157",
+  "pr_number": 10124,
+  "rust_files": [],
+  "diffs": []
+}

diffs/pr_10124/bdb3478/diff.json

@@ -0,0 +1,8 @@
+{
+  "commit_sha": "bdb3478d4f44034e7184356fe927f8ed509377fd",
+  "pr_number": 10124,
+  "rust_files": [
+    "crates/hyperswitch_connectors/src/connectors/fiserv/transformers.rs"
+  ],
+  "diffs": []
+}

diffs/pr_10124/c46e3a7/diff.json

@@ -0,0 +1,6 @@
+{
+  "commit_sha": "c46e3a73bbe19ed2e012fcbe105f9ae49c935dc9",
+  "pr_number": 10124,
+  "rust_files": [],
+  "diffs": []
+}

diffs/pr_10254/c2b8610/diff.json

@@ -0,0 +1,24 @@
+{
+  "commit_sha": "c2b86103b9a8fa3dd24d8f81abd491d83ec6cde0",
+  "pr_number": 10254,
+  "rust_files": [
+    "crates/router/src/core/payments.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/router/src/core/payments.rs::function::complete_preprocessing_steps_if_required",
+      "file": "crates/router/src/core/payments.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "async fn complete_preprocessing_steps_if_required<F, Req, Q, D>(\n    state: &SessionState,\n    connector: &api::ConnectorData,\n    payment_data: &D,\n    mut router_data: RouterData<F, Req, router_types::PaymentsResponseData>,\n    operation: &BoxedOperation<'_, F, Q, D>,\n    should_continue_payment: bool,\n) -> RouterResult<(RouterData<F, Req, router_types::PaymentsResponseData>, bool)>\nwhere\n    F: Send + Clone + Sync,\n    D: OperationSessionGetters<F> + Send + Sync + Clone,\n    Req: Send + Sync,\n    RouterData<F, Req, router_types::PaymentsResponseData>: Feature<F, Req> + Send,\n    dyn api::Connector:\n        services::api::ConnectorIntegration<F, Req, router_types::PaymentsResponseData>,\n{\n    //TODO: For ACH transfers, if preprocessing_step is not required for connectors encountered in future, add the check\n    let router_data_and_should_continue_payment = match payment_data.get_payment_method_data() {\n        Some(domain::PaymentMethodData::BankTransfer(_)) => (router_data, should_continue_payment),\n        Some(domain::PaymentMethodData::Wallet(_)) => {\n            if is_preprocessing_required_for_wallets(connector.connector_name.to_string()) {\n                (\n                    router_data.preprocessing_steps(state, connector).await?,\n                    false,\n                )\n            } else if connector.connector_name == router_types::Connector::Paysafe {\n                match payment_data.get_payment_method_data() {\n                    Some(domain::PaymentMethodData::Wallet(domain::WalletData::ApplePay(_))) => {\n                        router_data = router_data.preprocessing_steps(state, connector).await?;\n                        let is_error_in_response = router_data.response.is_err();\n                        (router_data, !is_error_in_response)\n                    }\n                    _ => (router_data, should_continue_payment),\n                }\n            } else {\n                (router_data, should_continue_payment)\n            }\n        }\n        Some(domain::PaymentMethodData::Card(_)) => {\n            if connector.connector_name == router_types::Connector::Payme\n                && !matches!(format!(\"{operation:?}\").as_str(), \"CompleteAuthorize\")\n            {\n                router_data = router_data.preprocessing_steps(state, connector).await?;\n\n                let is_error_in_response = router_data.response.is_err();\n                // If is_error_in_response is true, should_continue_payment should be false, we should throw the error\n                (router_data, !is_error_in_response)\n            } else if connector.connector_name == router_types::Connector::Nmi\n                && !matches!(format!(\"{operation:?}\").as_str(), \"CompleteAuthorize\")\n                && router_data.auth_type == storage_enums::AuthenticationType::ThreeDs\n                && !matches!(\n                    payment_data\n                        .get_payment_attempt()\n                        .external_three_ds_authentication_attempted,\n                    Some(true)\n                )\n            {\n                router_data = router_data.preprocessing_steps(state, connector).await?;\n\n                (router_data, false)\n            } else if connector.connector_name == router_types::Connector::Paysafe\n                && router_data.auth_type == storage_enums::AuthenticationType::NoThreeDs\n            {\n                router_data = router_data.preprocessing_steps(state, connector).await?;\n\n                let is_error_in_response = router_data.response.is_err();\n                // If is_error_in_response is true, should_continue_payment should be false, we should throw the error\n                (router_data, !is_error_in_response)\n            } else if (connector.connector_name == router_types::Connector::Cybersource\n                || connector.connector_name == router_types::Connector::Barclaycard)\n                && is_operation_complete_authorize(&operation)\n                && router_data.auth_type == storage_enums::AuthenticationType::ThreeDs\n            {\n                router_data = router_data.preprocessing_steps(state, connector).await?;\n\n                // Should continue the flow only if no redirection_data is returned else a response with redirection form shall be returned\n                let should_continue = matches!(\n                    router_data.response,\n                    Ok(router_types::PaymentsResponseData::TransactionResponse {\n                        ref redirection_data,\n                        ..\n                    }) if redirection_data.is_none()\n                ) && router_data.status\n                    != common_enums::AttemptStatus::AuthenticationFailed;\n                (router_data, should_continue)\n            } else if router_data.auth_type == common_enums::AuthenticationType::ThreeDs\n                && ((connector.connector_name == router_types::Connector::Nexixpay\n                    && is_operation_complete_authorize(&operation))\n                    || (((connector.connector_name == router_types::Connector::Nuvei && {\n                        #[cfg(feature = \"v1\")]\n                        {\n                            payment_data\n                                .get_payment_intent()\n                                .request_external_three_ds_authentication\n                                != Some(true)\n                        }\n                        #[cfg(feature = \"v2\")]\n                        {\n                            payment_data\n                                .get_payment_intent()\n                                .request_external_three_ds_authentication\n                                != Some(true).into()\n                        }\n                    }) || connector.connector_name == router_types::Connector::Shift4)\n                        && !is_operation_complete_authorize(&operation)))\n            {\n                router_data = router_data.preprocessing_steps(state, connector).await?;\n                (router_data, should_continue_payment)\n            } else if connector.connector_name == router_types::Connector::Xendit\n                && is_operation_confirm(&operation)\n            {\n                match payment_data.get_payment_intent().split_payments {\n                    Some(common_types::payments::SplitPaymentsRequest::XenditSplitPayment(\n                        common_types::payments::XenditSplitRequest::MultipleSplits(_),\n                    )) => {\n                        router_data = router_data.preprocessing_steps(state, connector).await?;\n                        let is_error_in_response = router_data.response.is_err();\n                        (router_data, !is_error_in_response)\n                    }\n                    _ => (router_data, should_continue_payment),\n                }\n            } else if connector.connector_name == router_types::Connector::Redsys\n                && router_data.auth_type == common_enums::AuthenticationType::ThreeDs\n                && is_operation_confirm(&operation)\n            {\n                router_data = router_data.preprocessing_steps(state, connector).await?;\n                let should_continue = match router_data.response {\n                    Ok(router_types::PaymentsResponseData::TransactionResponse {\n                        ref connector_metadata,\n                        ..\n                    }) => {\n                        let three_ds_invoke_data: Option<\n                            api_models::payments::PaymentsConnectorThreeDsInvokeData,\n                        > = connector_metadata.clone().and_then(|metadata| {\n                            metadata\n                                .parse_value(\"PaymentsConnectorThreeDsInvokeData\")\n                                .ok() // \"ThreeDsInvokeData was not found; proceeding with the payment flow without triggering the ThreeDS invoke action\"\n                        });\n                        three_ds_invoke_data.is_none()\n                    }\n                    _ => false,\n                };\n                (router_data, should_continue)\n            } else {\n                (router_data, should_continue_payment)\n            }\n        }\n        Some(domain::PaymentMethodData::GiftCard(gift_card_data)) => {\n            if connector.connector_name == router_types::Connector::Adyen\n                && matches!(gift_card_data.deref(), domain::GiftCardData::Givex(..))\n            {\n                router_data = router_data.preprocessing_steps(state, connector).await?;\n\n                let is_error_in_response = router_data.response.is_err();\n                // If is_error_in_response is true, should_continue_payment should be false, we should throw the error\n                (router_data, !is_error_in_response)\n            } else {\n                (router_data, should_continue_payment)\n            }\n        }\n        Some(domain::PaymentMethodData::BankDebit(_)) => {\n            if connector.connector_name == router_types::Connector::Gocardless\n                || connector.connector_name == router_types::Connector::Nordea\n            {\n                router_data = router_data.preprocessing_steps(state, connector).await?;\n                let is_error_in_response = router_data.response.is_err();\n                // If is_error_in_response is true, should_continue_payment should be false, we should throw the error\n                (router_data, !is_error_in_response)\n            } else {\n                (router_data, should_continue_payment)\n            }\n        }\n        _ => {\n            // 3DS validation for paypal cards after verification (authorize call)\n            if connector.connector_name == router_types::Connector::Paypal\n                && payment_data.get_payment_attempt().get_payment_method()\n                    == Some(storage_enums::PaymentMethod::Card)\n                && matches!(format!(\"{operation:?}\").as_str(), \"CompleteAuthorize\")\n            {\n                router_data = router_data.preprocessing_steps(state, connector).await?;\n                let is_error_in_response = router_data.response.is_err();\n                // If is_error_in_response is true, should_continue_payment should be false, we should throw the error\n                (router_data, !is_error_in_response)\n            } else {\n                (router_data, should_continue_payment)\n            }\n        }\n    };\n\n    Ok(router_data_and_should_continue_payment)\n}",
+      "after_code": "async fn complete_preprocessing_steps_if_required<F, Req, Q, D>(\n    state: &SessionState,\n    connector: &api::ConnectorData,\n    payment_data: &D,\n    mut router_data: RouterData<F, Req, router_types::PaymentsResponseData>,\n    operation: &BoxedOperation<'_, F, Q, D>,\n    should_continue_payment: bool,\n) -> RouterResult<(RouterData<F, Req, router_types::PaymentsResponseData>, bool)>\nwhere\n    F: Send + Clone + Sync,\n    D: OperationSessionGetters<F> + Send + Sync + Clone,\n    Req: Send + Sync,\n    RouterData<F, Req, router_types::PaymentsResponseData>: Feature<F, Req> + Send,\n    dyn api::Connector:\n        services::api::ConnectorIntegration<F, Req, router_types::PaymentsResponseData>,\n{\n    //TODO: For ACH transfers, if preprocessing_step is not required for connectors encountered in future, add the check\n    let router_data_and_should_continue_payment = match payment_data.get_payment_method_data() {\n        Some(domain::PaymentMethodData::BankTransfer(_)) => (router_data, should_continue_payment),\n        Some(domain::PaymentMethodData::Wallet(_)) => {\n            if is_preprocessing_required_for_wallets(connector.connector_name.to_string()) {\n                (\n                    router_data.preprocessing_steps(state, connector).await?,\n                    false,\n                )\n            } else if connector.connector_name == router_types::Connector::Paysafe {\n                match payment_data.get_payment_method_data() {\n                    Some(domain::PaymentMethodData::Wallet(domain::WalletData::ApplePay(_))) => {\n                        router_data = router_data.preprocessing_steps(state, connector).await?;\n                        let is_error_in_response = router_data.response.is_err();\n                        (router_data, !is_error_in_response)\n                    }\n                    _ => (router_data, should_continue_payment),\n                }\n            } else {\n                (router_data, should_continue_payment)\n            }\n        }\n        Some(domain::PaymentMethodData::Card(_)) => {\n            if connector.connector_name == router_types::Connector::Payme\n                && !matches!(format!(\"{operation:?}\").as_str(), \"CompleteAuthorize\")\n            {\n                router_data = router_data.preprocessing_steps(state, connector).await?;\n\n                let is_error_in_response = router_data.response.is_err();\n                // If is_error_in_response is true, should_continue_payment should be false, we should throw the error\n                (router_data, !is_error_in_response)\n            } else if connector.connector_name == router_types::Connector::Nmi\n                && !matches!(format!(\"{operation:?}\").as_str(), \"CompleteAuthorize\")\n                && router_data.auth_type == storage_enums::AuthenticationType::ThreeDs\n                && !matches!(\n                    payment_data\n                        .get_payment_attempt()\n                        .external_three_ds_authentication_attempted,\n                    Some(true)\n                )\n            {\n                router_data = router_data.preprocessing_steps(state, connector).await?;\n\n                (router_data, false)\n            } else if connector.connector_name == router_types::Connector::Paysafe\n                && router_data.auth_type == storage_enums::AuthenticationType::NoThreeDs\n            {\n                router_data = router_data.preprocessing_steps(state, connector).await?;\n\n                let is_error_in_response = router_data.response.is_err();\n                // If is_error_in_response is true, should_continue_payment should be false, we should throw the error\n                (router_data, !is_error_in_response)\n            } else if (connector.connector_name == router_types::Connector::Cybersource\n                || connector.connector_name == router_types::Connector::Barclaycard)\n                && is_operation_complete_authorize(&operation)\n                && router_data.auth_type == storage_enums::AuthenticationType::ThreeDs\n            {\n                router_data = router_data.preprocessing_steps(state, connector).await?;\n\n                // Should continue the flow only if no redirection_data is returned else a response with redirection form shall be returned\n                let should_continue = matches!(\n                    router_data.response,\n                    Ok(router_types::PaymentsResponseData::TransactionResponse {\n                        ref redirection_data,\n                        ..\n                    }) if redirection_data.is_none()\n                ) && router_data.status\n                    != common_enums::AttemptStatus::AuthenticationFailed;\n                (router_data, should_continue)\n            } else if router_data.auth_type == common_enums::AuthenticationType::ThreeDs\n                && (((connector.connector_name == router_types::Connector::Nuvei && {\n                    #[cfg(feature = \"v1\")]\n                    {\n                        payment_data\n                            .get_payment_intent()\n                            .request_external_three_ds_authentication\n                            != Some(true)\n                    }\n                    #[cfg(feature = \"v2\")]\n                    {\n                        payment_data\n                            .get_payment_intent()\n                            .request_external_three_ds_authentication\n                            != Some(true).into()\n                    }\n                }) || connector.connector_name == router_types::Connector::Shift4)\n                    && !is_operation_complete_authorize(&operation))\n            {\n                router_data = router_data.preprocessing_steps(state, connector).await?;\n                (router_data, should_continue_payment)\n            } else if connector.connector_name == router_types::Connector::Xendit\n                && is_operation_confirm(&operation)\n            {\n                match payment_data.get_payment_intent().split_payments {\n                    Some(common_types::payments::SplitPaymentsRequest::XenditSplitPayment(\n                        common_types::payments::XenditSplitRequest::MultipleSplits(_),\n                    )) => {\n                        router_data = router_data.preprocessing_steps(state, connector).await?;\n                        let is_error_in_response = router_data.response.is_err();\n                        (router_data, !is_error_in_response)\n                    }\n                    _ => (router_data, should_continue_payment),\n                }\n            } else if connector.connector_name == router_types::Connector::Redsys\n                && router_data.auth_type == common_enums::AuthenticationType::ThreeDs\n                && is_operation_confirm(&operation)\n            {\n                router_data = router_data.preprocessing_steps(state, connector).await?;\n                let should_continue = match router_data.response {\n                    Ok(router_types::PaymentsResponseData::TransactionResponse {\n                        ref connector_metadata,\n                        ..\n                    }) => {\n                        let three_ds_invoke_data: Option<\n                            api_models::payments::PaymentsConnectorThreeDsInvokeData,\n                        > = connector_metadata.clone().and_then(|metadata| {\n                            metadata\n                                .parse_value(\"PaymentsConnectorThreeDsInvokeData\")\n                                .ok() // \"ThreeDsInvokeData was not found; proceeding with the payment flow without triggering the ThreeDS invoke action\"\n                        });\n                        three_ds_invoke_data.is_none()\n                    }\n                    _ => false,\n                };\n                (router_data, should_continue)\n            } else if router_data.auth_type == common_enums::AuthenticationType::ThreeDs\n                && connector.connector_name == router_types::Connector::Nexixpay\n                && is_operation_complete_authorize(&operation)\n            {\n                router_data = router_data.preprocessing_steps(state, connector).await?;\n                let is_error_in_response = router_data.response.is_err();\n                (router_data, !is_error_in_response)\n            } else {\n                (router_data, should_continue_payment)\n            }\n        }\n        Some(domain::PaymentMethodData::GiftCard(gift_card_data)) => {\n            if connector.connector_name == router_types::Connector::Adyen\n                && matches!(gift_card_data.deref(), domain::GiftCardData::Givex(..))\n            {\n                router_data = router_data.preprocessing_steps(state, connector).await?;\n\n                let is_error_in_response = router_data.response.is_err();\n                // If is_error_in_response is true, should_continue_payment should be false, we should throw the error\n                (router_data, !is_error_in_response)\n            } else {\n                (router_data, should_continue_payment)\n            }\n        }\n        Some(domain::PaymentMethodData::BankDebit(_)) => {\n            if connector.connector_name == router_types::Connector::Gocardless\n                || connector.connector_name == router_types::Connector::Nordea\n            {\n                router_data = router_data.preprocessing_steps(state, connector).await?;\n                let is_error_in_response = router_data.response.is_err();\n                // If is_error_in_response is true, should_continue_payment should be false, we should throw the error\n                (router_data, !is_error_in_response)\n            } else {\n                (router_data, should_continue_payment)\n            }\n        }\n        _ => {\n            // 3DS validation for paypal cards after verification (authorize call)\n            if connector.connector_name == router_types::Connector::Paypal\n                && payment_data.get_payment_attempt().get_payment_method()\n                    == Some(storage_enums::PaymentMethod::Card)\n                && matches!(format!(\"{operation:?}\").as_str(), \"CompleteAuthorize\")\n            {\n                router_data = router_data.preprocessing_steps(state, connector).await?;\n                let is_error_in_response = router_data.response.is_err();\n                // If is_error_in_response is true, should_continue_payment should be false, we should throw the error\n                (router_data, !is_error_in_response)\n            } else {\n                (router_data, should_continue_payment)\n            }\n        }\n    };\n\n    Ok(router_data_and_should_continue_payment)\n}",
+      "diff_span": {
+        "before": "                (router_data, should_continue)\n            } else if router_data.auth_type == common_enums::AuthenticationType::ThreeDs\n                && ((connector.connector_name == router_types::Connector::Nexixpay\n                    && is_operation_complete_authorize(&operation))\n                    || (((connector.connector_name == router_types::Connector::Nuvei && {\n                        #[cfg(feature = \"v1\")]\n                        {\n                            payment_data\n                                .get_payment_intent()\n                                .request_external_three_ds_authentication\n                                != Some(true)\n                        }\n                        #[cfg(feature = \"v2\")]\n                        {\n                            payment_data\n                                .get_payment_intent()\n                                .request_external_three_ds_authentication\n                                != Some(true).into()\n                        }\n                    }) || connector.connector_name == router_types::Connector::Shift4)\n                        && !is_operation_complete_authorize(&operation)))\n            {\n                router_data = router_data.preprocessing_steps(state, connector).await?;",
+        "after": "                (router_data, should_continue)\n            } else if router_data.auth_type == common_enums::AuthenticationType::ThreeDs\n                && (((connector.connector_name == router_types::Connector::Nuvei && {\n                    #[cfg(feature = \"v1\")]\n                    {\n                        payment_data\n                            .get_payment_intent()\n                            .request_external_three_ds_authentication\n                            != Some(true)\n                    }\n                    #[cfg(feature = \"v2\")]\n                    {\n                        payment_data\n                            .get_payment_intent()\n                            .request_external_three_ds_authentication\n                            != Some(true).into()\n                    }\n                }) || connector.connector_name == router_types::Connector::Shift4)\n                    && !is_operation_complete_authorize(&operation))\n            {\n                router_data = router_data.preprocessing_steps(state, connector).await?;\n                (router_data, should_continue_payment)\n            } else if connector.connector_name == router_types::Connector::Xendit\n                && is_operation_confirm(&operation)\n            {\n                match payment_data.get_payment_intent().split_payments {\n                    Some(common_types::payments::SplitPaymentsRequest::XenditSplitPayment(\n                        common_types::payments::XenditSplitRequest::MultipleSplits(_),\n                    )) => {\n                        router_data = router_data.preprocessing_steps(state, connector).await?;\n                        let is_error_in_response = router_data.response.is_err();\n                        (router_data, !is_error_in_response)\n                    }\n                    _ => (router_data, should_continue_payment),\n                }\n            } else if connector.connector_name == router_types::Connector::Redsys\n                && router_data.auth_type == common_enums::AuthenticationType::ThreeDs\n                && is_operation_confirm(&operation)\n            {\n                router_data = router_data.preprocessing_steps(state, connector).await?;\n                let should_continue = match router_data.response {\n                    Ok(router_types::PaymentsResponseData::TransactionResponse {\n                        ref connector_metadata,\n                        ..\n                    }) => {\n                        let three_ds_invoke_data: Option<\n                            api_models::payments::PaymentsConnectorThreeDsInvokeData,\n                        > = connector_metadata.clone().and_then(|metadata| {\n                            metadata\n                                .parse_value(\"PaymentsConnectorThreeDsInvokeData\")\n                                .ok() // \"ThreeDsInvokeData was not found; proceeding with the payment flow without triggering the ThreeDS invoke action\"\n                        });\n                        three_ds_invoke_data.is_none()\n                    }\n                    _ => false,\n                };\n                (router_data, should_continue)\n            } else if router_data.auth_type == common_enums::AuthenticationType::ThreeDs\n                && connector.connector_name == router_types::Connector::Nexixpay\n                && is_operation_complete_authorize(&operation)\n            {\n                router_data = router_data.preprocessing_steps(state, connector).await?;\n                let is_error_in_response = router_data.response.is_err();\n                (router_data, !is_error_in_response)\n            } else {\n                (router_data, should_continue_payment)"
+      },
+      "commit_sha": "c2b86103b9a8fa3dd24d8f81abd491d83ec6cde0"
+    }
+  ]
+}

diffs/pr_6799/e84bbac/diff.json

@@ -0,0 +1,103 @@
+{
+  "commit_sha": "e84bbac225a92c5503492ecc28cc78572efcbd7c",
+  "pr_number": 6799,
+  "rust_files": [
+    "crates/masking/src/cassandra.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/masking/src/cassandra.rs::StrongSecret<T>::function::serialize",
+      "file": "crates/masking/src/cassandra.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": true,
+      "before_code": "fn serialize<'b>(\n        &self,\n        typ: &ColumnType,\n        writer: CellWriter<'b>,\n    ) -> Result<WrittenCellProof<'b>, SerializationError> {\n        self.peek().serialize(typ, writer)\n    }",
+      "after_code": "fn serialize<'b>(\n        &self,\n        typ: &ColumnType<'_>,\n        writer: CellWriter<'b>,\n    ) -> Result<WrittenCellProof<'b>, SerializationError> {\n        self.peek().serialize(typ, writer)\n    }",
+      "diff_span": {
+        "before": "fn serialize<'b>(\n        &self,\n        typ: &ColumnType,\n        writer: CellWriter<'b>,\n    ) -> Result<WrittenCellProof<'b>, SerializationError> {",
+        "after": "fn serialize<'b>(\n        &self,\n        typ: &ColumnType<'_>,\n        writer: CellWriter<'b>,\n    ) -> Result<WrittenCellProof<'b>, SerializationError> {"
+      },
+      "commit_sha": "e84bbac225a92c5503492ecc28cc78572efcbd7c",
+      "before_imports": [
+        "use scylla::{\n    cql_to_rust::FromCqlVal,\n    deserialize::DeserializeValue,\n    frame::response::result::{ColumnType, CqlValue},\n    serialize::{\n        value::SerializeValue,\n        writers::{CellWriter, WrittenCellProof},\n        SerializationError,\n    },\n};"
+      ],
+      "after_imports": [
+        "use scylla::{\n    deserialize::DeserializeValue,\n    frame::response::result::ColumnType,\n    serialize::{\n        value::SerializeValue,\n        writers::{CellWriter, WrittenCellProof},\n        SerializationError,\n    },\n};"
+      ]
+    },
+    {
+      "id": "crates/masking/src/cassandra.rs::StrongSecret<T>::function::type_check",
+      "file": "crates/masking/src/cassandra.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": true,
+      "before_code": "fn type_check(typ: &ColumnType) -> Result<(), scylla::deserialize::TypeCheckError> {\n        T::type_check(typ)\n    }",
+      "after_code": "fn type_check(typ: &ColumnType<'_>) -> Result<(), scylla::deserialize::TypeCheckError> {\n        T::type_check(typ)\n    }",
+      "diff_span": {
+        "before": "fn type_check(typ: &ColumnType) -> Result<(), scylla::deserialize::TypeCheckError> {\n        T::type_check(typ)\n    }",
+        "after": "fn type_check(typ: &ColumnType<'_>) -> Result<(), scylla::deserialize::TypeCheckError> {\n        T::type_check(typ)\n    }"
+      },
+      "commit_sha": "e84bbac225a92c5503492ecc28cc78572efcbd7c",
+      "before_imports": [
+        "use scylla::{\n    cql_to_rust::FromCqlVal,\n    deserialize::DeserializeValue,\n    frame::response::result::{ColumnType, CqlValue},\n    serialize::{\n        value::SerializeValue,\n        writers::{CellWriter, WrittenCellProof},\n        SerializationError,\n    },\n};"
+      ],
+      "after_imports": [
+        "use scylla::{\n    deserialize::DeserializeValue,\n    frame::response::result::ColumnType,\n    serialize::{\n        value::SerializeValue,\n        writers::{CellWriter, WrittenCellProof},\n        SerializationError,\n    },\n};"
+      ]
+    },
+    {
+      "id": "crates/masking/src/cassandra.rs::StrongSecret<T>::function::deserialize",
+      "file": "crates/masking/src/cassandra.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": true,
+      "before_code": "fn deserialize(\n        typ: &'frame ColumnType,\n        v: Option<scylla::deserialize::FrameSlice<'frame>>,\n    ) -> Result<Self, scylla::deserialize::DeserializationError> {\n        Ok(Self::new(T::deserialize(typ, v)?))\n    }",
+      "after_code": "fn deserialize(\n        typ: &'metadata ColumnType<'metadata>,\n        v: Option<scylla::deserialize::FrameSlice<'frame>>,\n    ) -> Result<Self, scylla::deserialize::DeserializationError> {\n        Ok(Self::new(T::deserialize(typ, v)?))\n    }",
+      "diff_span": {
+        "before": "fn deserialize(\n        typ: &'frame ColumnType,\n        v: Option<scylla::deserialize::FrameSlice<'frame>>,\n    ) -> Result<Self, scylla::deserialize::DeserializationError> {",
+        "after": "fn deserialize(\n        typ: &'metadata ColumnType<'metadata>,\n        v: Option<scylla::deserialize::FrameSlice<'frame>>,\n    ) -> Result<Self, scylla::deserialize::DeserializationError> {"
+      },
+      "commit_sha": "e84bbac225a92c5503492ecc28cc78572efcbd7c",
+      "before_imports": [
+        "use scylla::{\n    cql_to_rust::FromCqlVal,\n    deserialize::DeserializeValue,\n    frame::response::result::{ColumnType, CqlValue},\n    serialize::{\n        value::SerializeValue,\n        writers::{CellWriter, WrittenCellProof},\n        SerializationError,\n    },\n};"
+      ],
+      "after_imports": [
+        "use scylla::{\n    deserialize::DeserializeValue,\n    frame::response::result::ColumnType,\n    serialize::{\n        value::SerializeValue,\n        writers::{CellWriter, WrittenCellProof},\n        SerializationError,\n    },\n};"
+      ]
+    },
+    {
+      "id": "crates/masking/src/cassandra.rs::impl::StrongSecret<T>",
+      "file": "crates/masking/src/cassandra.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": true,
+      "before_code": "impl<T> FromCqlVal<CqlValue> for StrongSecret<T>\nwhere\n    T: FromCqlVal<CqlValue> + zeroize::Zeroize + Clone,\n{\n    fn from_cql(cql_val: CqlValue) -> Result<Self, scylla::cql_to_rust::FromCqlValError> {\n        Ok(Self::new(T::from_cql(cql_val)?))\n    }\n}",
+      "after_code": "impl<'frame, 'metadata, T> DeserializeValue<'frame, 'metadata> for StrongSecret<T>\nwhere\n    T: DeserializeValue<'frame, 'metadata> + zeroize::Zeroize + Clone,\n{\n    fn type_check(typ: &ColumnType<'_>) -> Result<(), scylla::deserialize::TypeCheckError> {\n        T::type_check(typ)\n    }\n\n    fn deserialize(\n        typ: &'metadata ColumnType<'metadata>,\n        v: Option<scylla::deserialize::FrameSlice<'frame>>,\n    ) -> Result<Self, scylla::deserialize::DeserializationError> {\n        Ok(Self::new(T::deserialize(typ, v)?))\n    }\n}",
+      "diff_span": {
+        "before": "impl<T> FromCqlVal<CqlValue> for StrongSecret<T>\nwhere\n    T: FromCqlVal<CqlValue> + zeroize::Zeroize + Clone,\n{\n    fn from_cql(cql_val: CqlValue) -> Result<Self, scylla::cql_to_rust::FromCqlValError> {\n        Ok(Self::new(T::from_cql(cql_val)?))\n    }\n}",
+        "after": "impl<'frame, 'metadata, T> DeserializeValue<'frame, 'metadata> for StrongSecret<T>\nwhere\n    T: DeserializeValue<'frame, 'metadata> + zeroize::Zeroize + Clone,\n{\n    fn type_check(typ: &ColumnType<'_>) -> Result<(), scylla::deserialize::TypeCheckError> {\n        T::type_check(typ)\n    }\n\n    fn deserialize(\n        typ: &'metadata ColumnType<'metadata>,\n        v: Option<scylla::deserialize::FrameSlice<'frame>>,\n    ) -> Result<Self, scylla::deserialize::DeserializationError> {\n        Ok(Self::new(T::deserialize(typ, v)?))\n    }\n}"
+      },
+      "commit_sha": "e84bbac225a92c5503492ecc28cc78572efcbd7c",
+      "before_imports": [
+        "use scylla::{\n    cql_to_rust::FromCqlVal,\n    deserialize::DeserializeValue,\n    frame::response::result::{ColumnType, CqlValue},\n    serialize::{\n        value::SerializeValue,\n        writers::{CellWriter, WrittenCellProof},\n        SerializationError,\n    },\n};"
+      ],
+      "after_imports": [
+        "use scylla::{\n    deserialize::DeserializeValue,\n    frame::response::result::ColumnType,\n    serialize::{\n        value::SerializeValue,\n        writers::{CellWriter, WrittenCellProof},\n        SerializationError,\n    },\n};"
+      ]
+    },
+    {
+      "id": "crates/masking/src/cassandra.rs::StrongSecret<T>::function::from_cql",
+      "file": "crates/masking/src/cassandra.rs",
+      "kind": "function_item",
+      "status": "removed",
+      "before_code": "fn from_cql(cql_val: CqlValue) -> Result<Self, scylla::cql_to_rust::FromCqlValError> {\n        Ok(Self::new(T::from_cql(cql_val)?))\n    }",
+      "after_code": null,
+      "diff_span": null,
+      "commit_sha": "e84bbac225a92c5503492ecc28cc78572efcbd7c"
+    }
+  ]
+}

diffs/pr_6836/1cef108/diff.json

@@ -0,0 +1,97 @@
+{
+  "commit_sha": "1cef108959b5436f53e67fd8c80c914485292276",
+  "pr_number": 6836,
+  "rust_files": [
+    "crates/common_utils/src/id_type.rs",
+    "crates/common_utils/src/id_type/global_id.rs",
+    "crates/common_utils/src/id_type/global_id/customer.rs",
+    "crates/common_utils/src/id_type/global_id/payment.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/common_utils/src/id_type/global_id.rs::mod::payment_methods",
+      "file": "crates/common_utils/src/id_type/global_id.rs",
+      "kind": "mod_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub mod payment_methods;",
+      "after_code": "pub(super) mod payment_methods;",
+      "diff_span": {
+        "before": "pub mod payment_methods;",
+        "after": "pub(super) mod payment_methods;"
+      },
+      "commit_sha": "1cef108959b5436f53e67fd8c80c914485292276"
+    },
+    {
+      "id": "crates/common_utils/src/id_type/global_id.rs::mod::payment",
+      "file": "crates/common_utils/src/id_type/global_id.rs",
+      "kind": "mod_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub mod payment;",
+      "after_code": "pub(super) mod payment;",
+      "diff_span": {
+        "before": "pub mod payment;",
+        "after": "pub(super) mod payment;"
+      },
+      "commit_sha": "1cef108959b5436f53e67fd8c80c914485292276"
+    },
+    {
+      "id": "crates/common_utils/src/id_type/global_id.rs::mod::refunds",
+      "file": "crates/common_utils/src/id_type/global_id.rs",
+      "kind": "mod_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub mod refunds;",
+      "after_code": "pub(super) mod refunds;",
+      "diff_span": {
+        "before": "pub mod refunds;",
+        "after": "pub(super) mod refunds;"
+      },
+      "commit_sha": "1cef108959b5436f53e67fd8c80c914485292276"
+    },
+    {
+      "id": "crates/common_utils/src/id_type/global_id.rs::mod::customer",
+      "file": "crates/common_utils/src/id_type/global_id.rs",
+      "kind": "mod_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "pub(super) mod customer;",
+      "diff_span": null,
+      "commit_sha": "1cef108959b5436f53e67fd8c80c914485292276"
+    },
+    {
+      "id": "crates/common_utils/src/id_type/global_id/customer.rs::impl::GlobalCustomerId",
+      "file": "crates/common_utils/src/id_type/global_id/customer.rs",
+      "kind": "impl_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "impl GlobalCustomerId {\n    /// Get string representation of the id\n    pub fn get_string_repr(&self) -> &str {\n        self.0.get_string_repr()\n    }\n\n    /// Generate a new GlobalCustomerId from a cell id\n    pub fn generate(cell_id: &crate::id_type::CellId) -> Self {\n        let global_id = super::GlobalId::generate(cell_id, super::GlobalEntity::Customer);\n        Self(global_id)\n    }\n}",
+      "diff_span": null,
+      "commit_sha": "1cef108959b5436f53e67fd8c80c914485292276"
+    },
+    {
+      "id": "crates/common_utils/src/id_type/global_id/customer.rs::GlobalCustomerId::function::generate",
+      "file": "crates/common_utils/src/id_type/global_id/customer.rs",
+      "kind": "function_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "pub fn generate(cell_id: &crate::id_type::CellId) -> Self {\n        let global_id = super::GlobalId::generate(cell_id, super::GlobalEntity::Customer);\n        Self(global_id)\n    }",
+      "diff_span": null,
+      "commit_sha": "1cef108959b5436f53e67fd8c80c914485292276"
+    },
+    {
+      "id": "crates/common_utils/src/id_type/global_id/customer.rs::GlobalCustomerId::function::get_string_repr",
+      "file": "crates/common_utils/src/id_type/global_id/customer.rs",
+      "kind": "function_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "pub fn get_string_repr(&self) -> &str {\n        self.0.get_string_repr()\n    }",
+      "diff_span": null,
+      "commit_sha": "1cef108959b5436f53e67fd8c80c914485292276"
+    }
+  ]
+}

diffs/pr_6836/24e7cc5/diff.json

@@ -0,0 +1,8 @@
+{
+  "commit_sha": "24e7cc52d8371d2bd85a20631cb3b268fb1a0f6c",
+  "pr_number": 6836,
+  "rust_files": [
+    "crates/router/src/routes/app.rs"
+  ],
+  "diffs": []
+}

diffs/pr_6836/2a72106/diff.json

@@ -0,0 +1,10 @@
+{
+  "commit_sha": "2a721067517999bf16ca253e7bd4c8c8fcc942ed",
+  "pr_number": 6836,
+  "rust_files": [
+    "crates/openapi/src/openapi.rs",
+    "crates/openapi/src/openapi_v2.rs",
+    "crates/openapi/src/routes/customers.rs"
+  ],
+  "diffs": []
+}

diffs/pr_6836/2f30119/diff.json

@@ -0,0 +1,24 @@
+{
+  "commit_sha": "2f30119c69a90e3cbfbed35da535b1be88518e97",
+  "pr_number": 6836,
+  "rust_files": [
+    "crates/api_models/src/customers.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/api_models/src/customers.rs::struct::CustomerResponse",
+      "file": "crates/api_models/src/customers.rs",
+      "kind": "struct_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub struct CustomerResponse {\n    /// The identifier for the customer object\n    #[schema(value_type = String, max_length = 64, min_length = 1, example = \"cus_y3oqhf46pyzuxjbcn2giaqnb44\")]\n    pub merchant_reference_id: Option<id_type::CustomerId>,\n    /// The customer's name\n    #[schema(max_length = 255, value_type = Option<String>, example = \"Jon Test\")]\n    pub name: crypto::OptionalEncryptableName,\n    /// The customer's email address\n    #[schema(value_type = Option<String> ,max_length = 255, example = \"JonTest@test.com\")]\n    pub email: crypto::OptionalEncryptableEmail,\n    /// The customer's phone number\n    #[schema(value_type = Option<String>,max_length = 255, example = \"9123456789\")]\n    pub phone: crypto::OptionalEncryptablePhone,\n    /// The country code for the customer phone number\n    #[schema(max_length = 255, example = \"+65\")]\n    pub phone_country_code: Option<String>,\n    /// An arbitrary string that you can attach to a customer object.\n    #[schema(max_length = 255, example = \"First Customer\", value_type = Option<String>)]\n    pub description: Option<Description>,\n    /// The default billing address for the customer\n    #[schema(value_type = Option<AddressDetails>)]\n    pub default_billing_address: Option<payments::AddressDetails>,\n    /// The default shipping address for the customer\n    #[schema(value_type = Option<AddressDetails>)]\n    pub default_shipping_address: Option<payments::AddressDetails>,\n    ///  A timestamp (ISO 8601 code) that determines when the customer was created\n    #[schema(value_type = PrimitiveDateTime,example = \"2023-01-18T11:04:09.922Z\")]\n    #[serde(with = \"custom_serde::iso8601\")]\n    pub created_at: time::PrimitiveDateTime,\n    /// You can specify up to 50 keys, with key names up to 40 characters long and values up to 500\n    /// characters long. Metadata is useful for storing additional, structured information on an\n    /// object.\n    #[schema(value_type = Option<Object>,example = json!({ \"city\": \"NY\", \"unit\": \"245\" }))]\n    pub metadata: Option<pii::SecretSerdeValue>,\n    /// The identifier for the default payment method.\n    #[schema(max_length = 64, example = \"pm_djh2837dwduh890123\")]\n    pub default_payment_method_id: Option<String>,\n    /// Global id\n    pub id: String,\n}",
+      "after_code": "pub struct CustomerResponse {\n    /// Global id\n    pub id: String,\n    /// The identifier for the customer object\n    #[schema(value_type = String, max_length = 64, min_length = 1, example = \"cus_y3oqhf46pyzuxjbcn2giaqnb44\")]\n    pub merchant_reference_id: Option<id_type::CustomerId>,\n    /// The customer's name\n    #[schema(max_length = 255, value_type = Option<String>, example = \"Jon Test\")]\n    pub name: crypto::OptionalEncryptableName,\n    /// The customer's email address\n    #[schema(value_type = Option<String> ,max_length = 255, example = \"JonTest@test.com\")]\n    pub email: crypto::OptionalEncryptableEmail,\n    /// The customer's phone number\n    #[schema(value_type = Option<String>,max_length = 255, example = \"9123456789\")]\n    pub phone: crypto::OptionalEncryptablePhone,\n    /// The country code for the customer phone number\n    #[schema(max_length = 255, example = \"+65\")]\n    pub phone_country_code: Option<String>,\n    /// An arbitrary string that you can attach to a customer object.\n    #[schema(max_length = 255, example = \"First Customer\", value_type = Option<String>)]\n    pub description: Option<Description>,\n    /// The default billing address for the customer\n    #[schema(value_type = Option<AddressDetails>)]\n    pub default_billing_address: Option<payments::AddressDetails>,\n    /// The default shipping address for the customer\n    #[schema(value_type = Option<AddressDetails>)]\n    pub default_shipping_address: Option<payments::AddressDetails>,\n    ///  A timestamp (ISO 8601 code) that determines when the customer was created\n    #[schema(value_type = PrimitiveDateTime,example = \"2023-01-18T11:04:09.922Z\")]\n    #[serde(with = \"custom_serde::iso8601\")]\n    pub created_at: time::PrimitiveDateTime,\n    /// You can specify up to 50 keys, with key names up to 40 characters long and values up to 500\n    /// characters long. Metadata is useful for storing additional, structured information on an\n    /// object.\n    #[schema(value_type = Option<Object>,example = json!({ \"city\": \"NY\", \"unit\": \"245\" }))]\n    pub metadata: Option<pii::SecretSerdeValue>,\n    /// The identifier for the default payment method.\n    #[schema(max_length = 64, example = \"pm_djh2837dwduh890123\")]\n    pub default_payment_method_id: Option<String>,\n}",
+      "diff_span": {
+        "before": "    #[schema(max_length = 64, example = \"pm_djh2837dwduh890123\")]\n    pub default_payment_method_id: Option<String>,\n    /// Global id\n    pub id: String,\n}",
+        "after": "pub struct CustomerResponse {\n    /// Global id\n    pub id: String,\n    /// The identifier for the customer object\n    #[schema(value_type = String, max_length = 64, min_length = 1, example = \"cus_y3oqhf46pyzuxjbcn2giaqnb44\")]"
+      },
+      "commit_sha": "2f30119c69a90e3cbfbed35da535b1be88518e97"
+    }
+  ]
+}

diffs/pr_6836/38cc82e/diff.json

@@ -0,0 +1,8 @@
+{
+  "commit_sha": "38cc82e1357c70fd115d7d2db6a300626b4cf024",
+  "pr_number": 6836,
+  "rust_files": [
+    "crates/api_models/src/customers.rs"
+  ],
+  "diffs": []
+}

diffs/pr_6836/3cbb5ba/diff.json

@@ -0,0 +1,39 @@
+{
+  "commit_sha": "3cbb5baa813f18f3288eb632b6bab5992effbb1b",
+  "pr_number": 6836,
+  "rust_files": [
+    "crates/api_models/src/customers.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/api_models/src/customers.rs::struct::CustomerDeleteResponse",
+      "file": "crates/api_models/src/customers.rs",
+      "kind": "struct_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub struct CustomerDeleteResponse {\n    /// Global id\n    pub id: id_type::GlobalCustomerId,\n    /// The identifier for the customer object\n    #[schema(value_type = String, max_length = 255, example = \"cus_y3oqhf46pyzuxjbcn2giaqnb44\")]\n    pub merchant_reference_id: Option<id_type::CustomerId>,\n    /// Whether customer was deleted or not\n    #[schema(example = false)]\n    pub customer_deleted: bool,\n    /// Whether address was deleted or not\n    #[schema(example = false)]\n    pub address_deleted: bool,\n    /// Whether payment methods deleted or not\n    #[schema(example = false)]\n    pub payment_methods_deleted: bool,\n}",
+      "after_code": "pub struct CustomerDeleteResponse {\n    /// Unique identifier for the customer\n    #[schema(\n        min_length = 32,\n        max_length = 64,\n        example = \"12345_cus_01926c58bc6e77c09e809964e72af8c8\",\n        value_type = String\n    )]\n    pub id: id_type::GlobalCustomerId,\n    /// The identifier for the customer object\n    #[schema(value_type = String, max_length = 255, example = \"cus_y3oqhf46pyzuxjbcn2giaqnb44\")]\n    pub merchant_reference_id: Option<id_type::CustomerId>,\n    /// Whether customer was deleted or not\n    #[schema(example = false)]\n    pub customer_deleted: bool,\n    /// Whether address was deleted or not\n    #[schema(example = false)]\n    pub address_deleted: bool,\n    /// Whether payment methods deleted or not\n    #[schema(example = false)]\n    pub payment_methods_deleted: bool,\n}",
+      "diff_span": {
+        "before": "pub struct CustomerDeleteResponse {\n    /// Global id\n    pub id: id_type::GlobalCustomerId,\n    /// The identifier for the customer object",
+        "after": "pub struct CustomerDeleteResponse {\n    /// Unique identifier for the customer\n    #[schema(\n        min_length = 32,\n        max_length = 64,\n        example = \"12345_cus_01926c58bc6e77c09e809964e72af8c8\",\n        value_type = String\n    )]\n    pub id: id_type::GlobalCustomerId,\n    /// The identifier for the customer object"
+      },
+      "commit_sha": "3cbb5baa813f18f3288eb632b6bab5992effbb1b"
+    },
+    {
+      "id": "crates/api_models/src/customers.rs::struct::CustomerResponse",
+      "file": "crates/api_models/src/customers.rs",
+      "kind": "struct_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub struct CustomerResponse {\n    /// Global id\n    pub id: id_type::GlobalCustomerId,\n    /// The identifier for the customer object\n    #[schema(value_type = String, max_length = 64, min_length = 1, example = \"cus_y3oqhf46pyzuxjbcn2giaqnb44\")]\n    pub merchant_reference_id: Option<id_type::CustomerId>,\n    /// The customer's name\n    #[schema(max_length = 255, value_type = Option<String>, example = \"Jon Test\")]\n    pub name: crypto::OptionalEncryptableName,\n    /// The customer's email address\n    #[schema(value_type = Option<String> ,max_length = 255, example = \"JonTest@test.com\")]\n    pub email: crypto::OptionalEncryptableEmail,\n    /// The customer's phone number\n    #[schema(value_type = Option<String>,max_length = 255, example = \"9123456789\")]\n    pub phone: crypto::OptionalEncryptablePhone,\n    /// The country code for the customer phone number\n    #[schema(max_length = 255, example = \"+65\")]\n    pub phone_country_code: Option<String>,\n    /// An arbitrary string that you can attach to a customer object.\n    #[schema(max_length = 255, example = \"First Customer\", value_type = Option<String>)]\n    pub description: Option<Description>,\n    /// The default billing address for the customer\n    #[schema(value_type = Option<AddressDetails>)]\n    pub default_billing_address: Option<payments::AddressDetails>,\n    /// The default shipping address for the customer\n    #[schema(value_type = Option<AddressDetails>)]\n    pub default_shipping_address: Option<payments::AddressDetails>,\n    ///  A timestamp (ISO 8601 code) that determines when the customer was created\n    #[schema(value_type = PrimitiveDateTime,example = \"2023-01-18T11:04:09.922Z\")]\n    #[serde(with = \"custom_serde::iso8601\")]\n    pub created_at: time::PrimitiveDateTime,\n    /// You can specify up to 50 keys, with key names up to 40 characters long and values up to 500\n    /// characters long. Metadata is useful for storing additional, structured information on an\n    /// object.\n    #[schema(value_type = Option<Object>,example = json!({ \"city\": \"NY\", \"unit\": \"245\" }))]\n    pub metadata: Option<pii::SecretSerdeValue>,\n    /// The identifier for the default payment method.\n    #[schema(max_length = 64, example = \"pm_djh2837dwduh890123\")]\n    pub default_payment_method_id: Option<String>,\n}",
+      "after_code": "pub struct CustomerResponse {\n    /// Unique identifier for the customer\n    #[schema(\n        min_length = 32,\n        max_length = 64,\n        example = \"12345_cus_01926c58bc6e77c09e809964e72af8c8\",\n        value_type = String\n    )]\n    pub id: id_type::GlobalCustomerId,\n    /// The identifier for the customer object\n    #[schema(value_type = String, max_length = 64, min_length = 1, example = \"cus_y3oqhf46pyzuxjbcn2giaqnb44\")]\n    pub merchant_reference_id: Option<id_type::CustomerId>,\n    /// The customer's name\n    #[schema(max_length = 255, value_type = Option<String>, example = \"Jon Test\")]\n    pub name: crypto::OptionalEncryptableName,\n    /// The customer's email address\n    #[schema(value_type = Option<String> ,max_length = 255, example = \"JonTest@test.com\")]\n    pub email: crypto::OptionalEncryptableEmail,\n    /// The customer's phone number\n    #[schema(value_type = Option<String>,max_length = 255, example = \"9123456789\")]\n    pub phone: crypto::OptionalEncryptablePhone,\n    /// The country code for the customer phone number\n    #[schema(max_length = 255, example = \"+65\")]\n    pub phone_country_code: Option<String>,\n    /// An arbitrary string that you can attach to a customer object.\n    #[schema(max_length = 255, example = \"First Customer\", value_type = Option<String>)]\n    pub description: Option<Description>,\n    /// The default billing address for the customer\n    #[schema(value_type = Option<AddressDetails>)]\n    pub default_billing_address: Option<payments::AddressDetails>,\n    /// The default shipping address for the customer\n    #[schema(value_type = Option<AddressDetails>)]\n    pub default_shipping_address: Option<payments::AddressDetails>,\n    ///  A timestamp (ISO 8601 code) that determines when the customer was created\n    #[schema(value_type = PrimitiveDateTime,example = \"2023-01-18T11:04:09.922Z\")]\n    #[serde(with = \"custom_serde::iso8601\")]\n    pub created_at: time::PrimitiveDateTime,\n    /// You can specify up to 50 keys, with key names up to 40 characters long and values up to 500\n    /// characters long. Metadata is useful for storing additional, structured information on an\n    /// object.\n    #[schema(value_type = Option<Object>,example = json!({ \"city\": \"NY\", \"unit\": \"245\" }))]\n    pub metadata: Option<pii::SecretSerdeValue>,\n    /// The identifier for the default payment method.\n    #[schema(max_length = 64, example = \"pm_djh2837dwduh890123\")]\n    pub default_payment_method_id: Option<String>,\n}",
+      "diff_span": {
+        "before": "pub struct CustomerResponse {\n    /// Global id\n    pub id: id_type::GlobalCustomerId,\n    /// The identifier for the customer object",
+        "after": "pub struct CustomerResponse {\n    /// Unique identifier for the customer\n    #[schema(\n        min_length = 32,\n        max_length = 64,\n        example = \"12345_cus_01926c58bc6e77c09e809964e72af8c8\",\n        value_type = String\n    )]\n    pub id: id_type::GlobalCustomerId,\n    /// The identifier for the customer object"
+      },
+      "commit_sha": "3cbb5baa813f18f3288eb632b6bab5992effbb1b"
+    }
+  ]
+}

diffs/pr_6836/61d7290/diff.json

@@ -0,0 +1,356 @@
+{
+  "commit_sha": "61d72906a8114a720b985f1dc50b2b087d22554a",
+  "pr_number": 6836,
+  "rust_files": [
+    "crates/api_models/src/customers.rs",
+    "crates/api_models/src/events/customer.rs",
+    "crates/common_utils/src/id_type/customer.rs",
+    "crates/router/src/compatibility/stripe/customers.rs",
+    "crates/router/src/core/customers.rs",
+    "crates/router/src/core/mandate.rs",
+    "crates/router/src/routes/customers.rs",
+    "crates/router/src/routes/ephemeral_key.rs",
+    "crates/router/src/types/api/customers.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/router/src/types/api/customers.rs::CustomerResponse::function::get_api_event_type",
+      "file": "crates/router/src/types/api/customers.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": false,
+      "imports_changed": true,
+      "before_code": "fn get_api_event_type(&self) -> Option<common_utils::events::ApiEventsType> {\n        self.0.get_api_event_type()\n    }",
+      "after_code": "fn get_api_event_type(&self) -> Option<common_utils::events::ApiEventsType> {\n        self.0.get_api_event_type()\n    }",
+      "diff_span": {
+        "before": "",
+        "after": ""
+      },
+      "commit_sha": "61d72906a8114a720b985f1dc50b2b087d22554a",
+      "before_imports": [
+        "pub use api_models::customers::{\n    CustomerDeleteResponse, CustomerId, CustomerListRequest, CustomerRequest,\n    CustomerUpdateRequest, CustomerUpdateRequestInternal,\n};",
+        "use crate::{\n    newtype,\n    types::{domain, ForeignFrom},\n};"
+      ],
+      "after_imports": [
+        "use crate::{\n    newtype,\n    types::{domain, ForeignFrom},\n};",
+        "pub use api_models::customers::{\n    CustomerDeleteResponse, CustomerListRequest, CustomerRequest, CustomerUpdateRequest,\n    CustomerUpdateRequestInternal,\n};"
+      ]
+    },
+    {
+      "id": "crates/router/src/routes/customers.rs::function::get_customer_mandates",
+      "file": "crates/router/src/routes/customers.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn get_customer_mandates(\n    state: web::Data<AppState>,\n    req: HttpRequest,\n    path: web::Path<id_type::CustomerId>,\n) -> impl Responder {\n    let flow = Flow::CustomersGetMandates;\n    let customer_id = customers::CustomerId {\n        customer_id: path.into_inner(),\n    };\n\n    Box::pin(api::server_wrap(\n        flow,\n        state,\n        &req,\n        customer_id,\n        |state, auth: auth::AuthenticationData, req, _| {\n            crate::core::mandate::get_customer_mandates(\n                state,\n                auth.merchant_account,\n                auth.key_store,\n                req,\n            )\n        },\n        auth::auth_type(\n            &auth::HeaderAuth(auth::ApiKeyAuth),\n            &auth::JWTAuth {\n                permission: Permission::MerchantMandateRead,\n            },\n            req.headers(),\n        ),\n        api_locking::LockAction::NotApplicable,\n    ))\n    .await\n}",
+      "after_code": "pub async fn get_customer_mandates(\n    state: web::Data<AppState>,\n    req: HttpRequest,\n    path: web::Path<id_type::CustomerId>,\n) -> impl Responder {\n    let flow = Flow::CustomersGetMandates;\n    let customer_id = path.into_inner();\n\n    Box::pin(api::server_wrap(\n        flow,\n        state,\n        &req,\n        customer_id,\n        |state, auth: auth::AuthenticationData, customer_id, _| {\n            crate::core::mandate::get_customer_mandates(\n                state,\n                auth.merchant_account,\n                auth.key_store,\n                customer_id,\n            )\n        },\n        auth::auth_type(\n            &auth::HeaderAuth(auth::ApiKeyAuth),\n            &auth::JWTAuth {\n                permission: Permission::MerchantMandateRead,\n            },\n            req.headers(),\n        ),\n        api_locking::LockAction::NotApplicable,\n    ))\n    .await\n}",
+      "diff_span": {
+        "before": ") -> impl Responder {\n    let flow = Flow::CustomersGetMandates;\n    let customer_id = customers::CustomerId {\n        customer_id: path.into_inner(),\n    };\n\n    Box::pin(api::server_wrap(\n        flow,\n        state,\n        &req,\n        customer_id,\n        |state, auth: auth::AuthenticationData, req, _| {\n            crate::core::mandate::get_customer_mandates(\n                state,\n                auth.merchant_account,\n                auth.key_store,\n                req,\n            )\n        },",
+        "after": ") -> impl Responder {\n    let flow = Flow::CustomersGetMandates;\n    let customer_id = path.into_inner();\n\n    Box::pin(api::server_wrap(\n        flow,\n        state,\n        &req,\n        customer_id,\n        |state, auth: auth::AuthenticationData, customer_id, _| {\n            crate::core::mandate::get_customer_mandates(\n                state,\n                auth.merchant_account,\n                auth.key_store,\n                customer_id,\n            )\n        },"
+      },
+      "commit_sha": "61d72906a8114a720b985f1dc50b2b087d22554a"
+    },
+    {
+      "id": "crates/router/src/types/api/customers.rs::CustomerResponse::function::foreign_from",
+      "file": "crates/router/src/types/api/customers.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": false,
+      "imports_changed": true,
+      "before_code": "fn foreign_from(cust: domain::Customer) -> Self {\n        customers::CustomerResponse {\n            merchant_reference_id: cust.merchant_reference_id,\n            name: cust.name,\n            email: cust.email,\n            phone: cust.phone,\n            phone_country_code: cust.phone_country_code,\n            description: cust.description,\n            created_at: cust.created_at,\n            metadata: cust.metadata,\n            default_billing_address: None,\n            default_shipping_address: None,\n            default_payment_method_id: cust.default_payment_method_id,\n            id: cust.id,\n        }\n        .into()\n    }",
+      "after_code": "fn foreign_from(cust: domain::Customer) -> Self {\n        customers::CustomerResponse {\n            merchant_reference_id: cust.merchant_reference_id,\n            name: cust.name,\n            email: cust.email,\n            phone: cust.phone,\n            phone_country_code: cust.phone_country_code,\n            description: cust.description,\n            created_at: cust.created_at,\n            metadata: cust.metadata,\n            default_billing_address: None,\n            default_shipping_address: None,\n            default_payment_method_id: cust.default_payment_method_id,\n            id: cust.id,\n        }\n        .into()\n    }",
+      "diff_span": {
+        "before": "",
+        "after": ""
+      },
+      "commit_sha": "61d72906a8114a720b985f1dc50b2b087d22554a",
+      "before_imports": [
+        "use hyperswitch_domain_models::customer;",
+        "use api_models::customers;",
+        "pub use api_models::customers::{\n    CustomerDeleteResponse, CustomerId, CustomerListRequest, CustomerRequest,\n    CustomerUpdateRequest, CustomerUpdateRequestInternal,\n};",
+        "use crate::{\n    newtype,\n    types::{domain, ForeignFrom},\n};"
+      ],
+      "after_imports": [
+        "use hyperswitch_domain_models::customer;",
+        "use api_models::customers;",
+        "use crate::{\n    newtype,\n    types::{domain, ForeignFrom},\n};",
+        "pub use api_models::customers::{\n    CustomerDeleteResponse, CustomerListRequest, CustomerRequest, CustomerUpdateRequest,\n    CustomerUpdateRequestInternal,\n};"
+      ]
+    },
+    {
+      "id": "crates/router/src/routes/ephemeral_key.rs::function::ephemeral_key_create",
+      "file": "crates/router/src/routes/ephemeral_key.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": true,
+      "before_code": "pub async fn ephemeral_key_create(\n    state: web::Data<AppState>,\n    req: HttpRequest,\n    json_payload: web::Json<customers::CustomerId>,\n) -> HttpResponse {\n    let flow = Flow::EphemeralKeyCreate;\n    let payload = json_payload.into_inner();\n    api::server_wrap(\n        flow,\n        state,\n        &req,\n        payload,\n        |state, auth: auth::AuthenticationData, req, _| {\n            helpers::make_ephemeral_key(\n                state,\n                req.get_merchant_reference_id(),\n                auth.merchant_account.get_id().to_owned(),\n            )\n        },\n        &auth::HeaderAuth(auth::ApiKeyAuth),\n        api_locking::LockAction::NotApplicable,\n    )\n    .await\n}",
+      "after_code": "pub async fn ephemeral_key_create(\n    state: web::Data<AppState>,\n    req: HttpRequest,\n    json_payload: web::Json<common_utils::id_type::CustomerId>,\n) -> HttpResponse {\n    let flow = Flow::EphemeralKeyCreate;\n    let customer_id = json_payload.into_inner();\n    api::server_wrap(\n        flow,\n        state,\n        &req,\n        customer_id,\n        |state, auth: auth::AuthenticationData, customer_id, _| {\n            helpers::make_ephemeral_key(\n                state,\n                customer_id,\n                auth.merchant_account.get_id().to_owned(),\n            )\n        },\n        &auth::HeaderAuth(auth::ApiKeyAuth),\n        api_locking::LockAction::NotApplicable,\n    )\n    .await\n}",
+      "diff_span": {
+        "before": "    state: web::Data<AppState>,\n    req: HttpRequest,\n    json_payload: web::Json<customers::CustomerId>,\n) -> HttpResponse {\n    let flow = Flow::EphemeralKeyCreate;\n    let payload = json_payload.into_inner();\n    api::server_wrap(\n        flow,\n        state,\n        &req,\n        payload,\n        |state, auth: auth::AuthenticationData, req, _| {\n            helpers::make_ephemeral_key(\n                state,\n                req.get_merchant_reference_id(),\n                auth.merchant_account.get_id().to_owned(),\n            )",
+        "after": "    state: web::Data<AppState>,\n    req: HttpRequest,\n    json_payload: web::Json<common_utils::id_type::CustomerId>,\n) -> HttpResponse {\n    let flow = Flow::EphemeralKeyCreate;\n    let customer_id = json_payload.into_inner();\n    api::server_wrap(\n        flow,\n        state,\n        &req,\n        customer_id,\n        |state, auth: auth::AuthenticationData, customer_id, _| {\n            helpers::make_ephemeral_key(\n                state,\n                customer_id,\n                auth.merchant_account.get_id().to_owned(),\n            )"
+      },
+      "commit_sha": "61d72906a8114a720b985f1dc50b2b087d22554a",
+      "before_imports": [
+        "use actix_web::{web, HttpRequest, HttpResponse};",
+        "use router_env::{instrument, tracing, Flow};",
+        "use super::AppState;"
+      ],
+      "after_imports": [
+        "use actix_web::{web, HttpRequest, HttpResponse};",
+        "use router_env::{instrument, tracing, Flow};",
+        "use crate::{\n    core::{api_locking, payments::helpers},\n    services::{api, authentication as auth},\n};",
+        "use super::AppState;"
+      ]
+    },
+    {
+      "id": "crates/router/src/core/customers.rs::function::delete_customer",
+      "file": "crates/router/src/core/customers.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn delete_customer(\n    state: SessionState,\n    merchant_account: domain::MerchantAccount,\n    req: customers::CustomerId,\n    key_store: domain::MerchantKeyStore,\n) -> errors::CustomerResponse<customers::CustomerDeleteResponse> {\n    let db = &*state.store;\n    let key_manager_state = &(&state).into();\n    req.fetch_domain_model_and_update_and_generate_delete_customer_response(\n        db,\n        &key_store,\n        &merchant_account,\n        key_manager_state,\n        &state,\n    )\n    .await\n}",
+      "after_code": "pub async fn delete_customer(\n    state: SessionState,\n    merchant_account: domain::MerchantAccount,\n    customer_id: id_type::CustomerId,\n    key_store: domain::MerchantKeyStore,\n) -> errors::CustomerResponse<customers::CustomerDeleteResponse> {\n    let db = &*state.store;\n    let key_manager_state = &(&state).into();\n    customer_id\n        .fetch_domain_model_and_update_and_generate_delete_customer_response(\n            db,\n            &key_store,\n            &merchant_account,\n            key_manager_state,\n            &state,\n        )\n        .await\n}",
+      "diff_span": {
+        "before": "    state: SessionState,\n    merchant_account: domain::MerchantAccount,\n    req: customers::CustomerId,\n    key_store: domain::MerchantKeyStore,\n) -> errors::CustomerResponse<customers::CustomerDeleteResponse> {\n    let db = &*state.store;\n    let key_manager_state = &(&state).into();\n    req.fetch_domain_model_and_update_and_generate_delete_customer_response(\n        db,\n        &key_store,\n        &merchant_account,\n        key_manager_state,\n        &state,\n    )\n    .await\n}",
+        "after": "    state: SessionState,\n    merchant_account: domain::MerchantAccount,\n    customer_id: id_type::CustomerId,\n    key_store: domain::MerchantKeyStore,\n) -> errors::CustomerResponse<customers::CustomerDeleteResponse> {\n    let db = &*state.store;\n    let key_manager_state = &(&state).into();\n    customer_id\n        .fetch_domain_model_and_update_and_generate_delete_customer_response(\n            db,\n            &key_store,\n            &merchant_account,\n            key_manager_state,\n            &state,\n        )\n        .await\n}"
+      },
+      "commit_sha": "61d72906a8114a720b985f1dc50b2b087d22554a"
+    },
+    {
+      "id": "crates/router/src/compatibility/stripe/customers.rs::function::customer_delete",
+      "file": "crates/router/src/compatibility/stripe/customers.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn customer_delete(\n    state: web::Data<routes::AppState>,\n    req: HttpRequest,\n    path: web::Path<id_type::CustomerId>,\n) -> HttpResponse {\n    let payload = customer_types::CustomerId::new_customer_id_struct(path.into_inner());\n\n    let flow = Flow::CustomersDelete;\n\n    Box::pin(wrap::compatibility_api_wrap::<\n        _,\n        _,\n        _,\n        _,\n        _,\n        types::CustomerDeleteResponse,\n        errors::StripeErrorCode,\n        _,\n    >(\n        flow,\n        state.into_inner(),\n        &req,\n        payload,\n        |state, auth: auth::AuthenticationData, req, _| {\n            customers::delete_customer(state, auth.merchant_account, req, auth.key_store)\n        },\n        &auth::HeaderAuth(auth::ApiKeyAuth),\n        api_locking::LockAction::NotApplicable,\n    ))\n    .await\n}",
+      "after_code": "pub async fn customer_delete(\n    state: web::Data<routes::AppState>,\n    req: HttpRequest,\n    path: web::Path<id_type::CustomerId>,\n) -> HttpResponse {\n    let customer_id = path.into_inner();\n\n    let flow = Flow::CustomersDelete;\n\n    Box::pin(wrap::compatibility_api_wrap::<\n        _,\n        _,\n        _,\n        _,\n        _,\n        types::CustomerDeleteResponse,\n        errors::StripeErrorCode,\n        _,\n    >(\n        flow,\n        state.into_inner(),\n        &req,\n        customer_id,\n        |state, auth: auth::AuthenticationData, customer_id, _| {\n            customers::delete_customer(state, auth.merchant_account, customer_id, auth.key_store)\n        },\n        &auth::HeaderAuth(auth::ApiKeyAuth),\n        api_locking::LockAction::NotApplicable,\n    ))\n    .await\n}",
+      "diff_span": {
+        "before": "    path: web::Path<id_type::CustomerId>,\n) -> HttpResponse {\n    let payload = customer_types::CustomerId::new_customer_id_struct(path.into_inner());\n\n    let flow = Flow::CustomersDelete;\n\n    Box::pin(wrap::compatibility_api_wrap::<\n        _,\n        _,\n        _,\n        _,\n        _,\n        types::CustomerDeleteResponse,\n        errors::StripeErrorCode,\n        _,\n    >(\n        flow,\n        state.into_inner(),\n        &req,\n        payload,\n        |state, auth: auth::AuthenticationData, req, _| {\n            customers::delete_customer(state, auth.merchant_account, req, auth.key_store)\n        },\n        &auth::HeaderAuth(auth::ApiKeyAuth),",
+        "after": "    path: web::Path<id_type::CustomerId>,\n) -> HttpResponse {\n    let customer_id = path.into_inner();\n\n    let flow = Flow::CustomersDelete;\n\n    Box::pin(wrap::compatibility_api_wrap::<\n        _,\n        _,\n        _,\n        _,\n        _,\n        types::CustomerDeleteResponse,\n        errors::StripeErrorCode,\n        _,\n    >(\n        flow,\n        state.into_inner(),\n        &req,\n        customer_id,\n        |state, auth: auth::AuthenticationData, customer_id, _| {\n            customers::delete_customer(state, auth.merchant_account, customer_id, auth.key_store)\n        },\n        &auth::HeaderAuth(auth::ApiKeyAuth),"
+      },
+      "commit_sha": "61d72906a8114a720b985f1dc50b2b087d22554a"
+    },
+    {
+      "id": "crates/router/src/compatibility/stripe/customers.rs::function::customer_retrieve",
+      "file": "crates/router/src/compatibility/stripe/customers.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn customer_retrieve(\n    state: web::Data<routes::AppState>,\n    req: HttpRequest,\n    path: web::Path<id_type::CustomerId>,\n) -> HttpResponse {\n    let payload = customer_types::CustomerId::new_customer_id_struct(path.into_inner());\n\n    let flow = Flow::CustomersRetrieve;\n\n    Box::pin(wrap::compatibility_api_wrap::<\n        _,\n        _,\n        _,\n        _,\n        _,\n        types::CustomerRetrieveResponse,\n        errors::StripeErrorCode,\n        _,\n    >(\n        flow,\n        state.into_inner(),\n        &req,\n        payload,\n        |state, auth: auth::AuthenticationData, req, _| {\n            customers::retrieve_customer(state, auth.merchant_account, None, auth.key_store, req)\n        },\n        &auth::HeaderAuth(auth::ApiKeyAuth),\n        api_locking::LockAction::NotApplicable,\n    ))\n    .await\n}",
+      "after_code": "pub async fn customer_retrieve(\n    state: web::Data<routes::AppState>,\n    req: HttpRequest,\n    path: web::Path<id_type::CustomerId>,\n) -> HttpResponse {\n    let customer_id = path.into_inner();\n\n    let flow = Flow::CustomersRetrieve;\n\n    Box::pin(wrap::compatibility_api_wrap::<\n        _,\n        _,\n        _,\n        _,\n        _,\n        types::CustomerRetrieveResponse,\n        errors::StripeErrorCode,\n        _,\n    >(\n        flow,\n        state.into_inner(),\n        &req,\n        customer_id,\n        |state, auth: auth::AuthenticationData, customer_id, _| {\n            customers::retrieve_customer(\n                state,\n                auth.merchant_account,\n                None,\n                auth.key_store,\n                customer_id,\n            )\n        },\n        &auth::HeaderAuth(auth::ApiKeyAuth),\n        api_locking::LockAction::NotApplicable,\n    ))\n    .await\n}",
+      "diff_span": {
+        "before": "    path: web::Path<id_type::CustomerId>,\n) -> HttpResponse {\n    let payload = customer_types::CustomerId::new_customer_id_struct(path.into_inner());\n\n    let flow = Flow::CustomersRetrieve;\n\n    Box::pin(wrap::compatibility_api_wrap::<\n        _,\n        _,\n        _,\n        _,\n        _,\n        types::CustomerRetrieveResponse,\n        errors::StripeErrorCode,\n        _,\n    >(\n        flow,\n        state.into_inner(),\n        &req,\n        payload,\n        |state, auth: auth::AuthenticationData, req, _| {\n            customers::retrieve_customer(state, auth.merchant_account, None, auth.key_store, req)\n        },\n        &auth::HeaderAuth(auth::ApiKeyAuth),",
+        "after": "    path: web::Path<id_type::CustomerId>,\n) -> HttpResponse {\n    let customer_id = path.into_inner();\n\n    let flow = Flow::CustomersRetrieve;\n\n    Box::pin(wrap::compatibility_api_wrap::<\n        _,\n        _,\n        _,\n        _,\n        _,\n        types::CustomerRetrieveResponse,\n        errors::StripeErrorCode,\n        _,\n    >(\n        flow,\n        state.into_inner(),\n        &req,\n        customer_id,\n        |state, auth: auth::AuthenticationData, customer_id, _| {\n            customers::retrieve_customer(\n                state,\n                auth.merchant_account,\n                None,\n                auth.key_store,\n                customer_id,\n            )\n        },\n        &auth::HeaderAuth(auth::ApiKeyAuth),"
+      },
+      "commit_sha": "61d72906a8114a720b985f1dc50b2b087d22554a"
+    },
+    {
+      "id": "crates/router/src/routes/ephemeral_key.rs::function::ephemeral_key_delete",
+      "file": "crates/router/src/routes/ephemeral_key.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": false,
+      "imports_changed": true,
+      "before_code": "pub async fn ephemeral_key_delete(\n    state: web::Data<AppState>,\n    req: HttpRequest,\n    path: web::Path<String>,\n) -> HttpResponse {\n    let flow = Flow::EphemeralKeyDelete;\n    let payload = path.into_inner();\n    api::server_wrap(\n        flow,\n        state,\n        &req,\n        payload,\n        |state, _: auth::AuthenticationData, req, _| helpers::delete_ephemeral_key(state, req),\n        &auth::HeaderAuth(auth::ApiKeyAuth),\n        api_locking::LockAction::NotApplicable,\n    )\n    .await\n}",
+      "after_code": "pub async fn ephemeral_key_delete(\n    state: web::Data<AppState>,\n    req: HttpRequest,\n    path: web::Path<String>,\n) -> HttpResponse {\n    let flow = Flow::EphemeralKeyDelete;\n    let payload = path.into_inner();\n    api::server_wrap(\n        flow,\n        state,\n        &req,\n        payload,\n        |state, _: auth::AuthenticationData, req, _| helpers::delete_ephemeral_key(state, req),\n        &auth::HeaderAuth(auth::ApiKeyAuth),\n        api_locking::LockAction::NotApplicable,\n    )\n    .await\n}",
+      "diff_span": {
+        "before": "",
+        "after": ""
+      },
+      "commit_sha": "61d72906a8114a720b985f1dc50b2b087d22554a",
+      "before_imports": [
+        "use actix_web::{web, HttpRequest, HttpResponse};",
+        "use router_env::{instrument, tracing, Flow};",
+        "use super::AppState;"
+      ],
+      "after_imports": [
+        "use actix_web::{web, HttpRequest, HttpResponse};",
+        "use router_env::{instrument, tracing, Flow};",
+        "use crate::{\n    core::{api_locking, payments::helpers},\n    services::{api, authentication as auth},\n};",
+        "use super::AppState;"
+      ]
+    },
+    {
+      "id": "crates/router/src/core/mandate.rs::function::get_customer_mandates",
+      "file": "crates/router/src/core/mandate.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn get_customer_mandates(\n    state: SessionState,\n    merchant_account: domain::MerchantAccount,\n    key_store: domain::MerchantKeyStore,\n    req: customers::CustomerId,\n) -> RouterResponse<Vec<mandates::MandateResponse>> {\n    let mandates = state\n        .store\n        .find_mandate_by_merchant_id_customer_id(\n            merchant_account.get_id(),\n            &req.get_merchant_reference_id(),\n        )\n        .await\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable_lazy(|| {\n            format!(\n                \"Failed while finding mandate: merchant_id: {:?}, customer_id: {:?}\",\n                merchant_account.get_id(),\n                req.get_merchant_reference_id()\n            )\n        })?;\n\n    if mandates.is_empty() {\n        Err(report!(errors::ApiErrorResponse::MandateNotFound).attach_printable(\"No Mandate found\"))\n    } else {\n        let mut response_vec = Vec::with_capacity(mandates.len());\n        for mandate in mandates {\n            response_vec.push(\n                mandates::MandateResponse::from_db_mandate(\n                    &state,\n                    key_store.clone(),\n                    mandate,\n                    merchant_account.storage_scheme,\n                )\n                .await?,\n            );\n        }\n        Ok(services::ApplicationResponse::Json(response_vec))\n    }\n}",
+      "after_code": "pub async fn get_customer_mandates(\n    state: SessionState,\n    merchant_account: domain::MerchantAccount,\n    key_store: domain::MerchantKeyStore,\n    customer_id: id_type::CustomerId,\n) -> RouterResponse<Vec<mandates::MandateResponse>> {\n    let mandates = state\n        .store\n        .find_mandate_by_merchant_id_customer_id(merchant_account.get_id(), &customer_id)\n        .await\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable_lazy(|| {\n            format!(\n                \"Failed while finding mandate: merchant_id: {:?}, customer_id: {:?}\",\n                merchant_account.get_id(),\n                customer_id,\n            )\n        })?;\n\n    if mandates.is_empty() {\n        Err(report!(errors::ApiErrorResponse::MandateNotFound).attach_printable(\"No Mandate found\"))\n    } else {\n        let mut response_vec = Vec::with_capacity(mandates.len());\n        for mandate in mandates {\n            response_vec.push(\n                mandates::MandateResponse::from_db_mandate(\n                    &state,\n                    key_store.clone(),\n                    mandate,\n                    merchant_account.storage_scheme,\n                )\n                .await?,\n            );\n        }\n        Ok(services::ApplicationResponse::Json(response_vec))\n    }\n}",
+      "diff_span": {
+        "before": "    merchant_account: domain::MerchantAccount,\n    key_store: domain::MerchantKeyStore,\n    req: customers::CustomerId,\n) -> RouterResponse<Vec<mandates::MandateResponse>> {\n    let mandates = state\n        .store\n        .find_mandate_by_merchant_id_customer_id(\n            merchant_account.get_id(),\n            &req.get_merchant_reference_id(),\n        )\n        .await\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable_lazy(|| {\n            format!(\n                \"Failed while finding mandate: merchant_id: {:?}, customer_id: {:?}\",\n                merchant_account.get_id(),\n                req.get_merchant_reference_id()\n            )\n        })?;",
+        "after": "    merchant_account: domain::MerchantAccount,\n    key_store: domain::MerchantKeyStore,\n    customer_id: id_type::CustomerId,\n) -> RouterResponse<Vec<mandates::MandateResponse>> {\n    let mandates = state\n        .store\n        .find_mandate_by_merchant_id_customer_id(merchant_account.get_id(), &customer_id)\n        .await\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable_lazy(|| {\n            format!(\n                \"Failed while finding mandate: merchant_id: {:?}, customer_id: {:?}\",\n                merchant_account.get_id(),\n                customer_id,\n            )\n        })?;"
+      },
+      "commit_sha": "61d72906a8114a720b985f1dc50b2b087d22554a"
+    },
+    {
+      "id": "crates/router/src/routes/customers.rs::function::customers_delete",
+      "file": "crates/router/src/routes/customers.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn customers_delete(\n    state: web::Data<AppState>,\n    req: HttpRequest,\n    path: web::Path<id_type::CustomerId>,\n) -> impl Responder {\n    let flow = Flow::CustomersDelete;\n    let payload = web::Json(customers::CustomerId {\n        customer_id: path.into_inner(),\n    })\n    .into_inner();\n\n    Box::pin(api::server_wrap(\n        flow,\n        state,\n        &req,\n        payload,\n        |state, auth: auth::AuthenticationData, req, _| {\n            delete_customer(state, auth.merchant_account, req, auth.key_store)\n        },\n        auth::auth_type(\n            &auth::HeaderAuth(auth::ApiKeyAuth),\n            &auth::JWTAuth {\n                permission: Permission::MerchantCustomerWrite,\n            },\n            req.headers(),\n        ),\n        api_locking::LockAction::NotApplicable,\n    ))\n    .await\n}",
+      "after_code": "pub async fn customers_delete(\n    state: web::Data<AppState>,\n    req: HttpRequest,\n    path: web::Path<id_type::CustomerId>,\n) -> impl Responder {\n    let flow = Flow::CustomersDelete;\n    let customer_id = path.into_inner();\n\n    Box::pin(api::server_wrap(\n        flow,\n        state,\n        &req,\n        customer_id,\n        |state, auth: auth::AuthenticationData, customer_id, _| {\n            delete_customer(state, auth.merchant_account, customer_id, auth.key_store)\n        },\n        auth::auth_type(\n            &auth::HeaderAuth(auth::ApiKeyAuth),\n            &auth::JWTAuth {\n                permission: Permission::MerchantCustomerWrite,\n            },\n            req.headers(),\n        ),\n        api_locking::LockAction::NotApplicable,\n    ))\n    .await\n}",
+      "diff_span": {
+        "before": ") -> impl Responder {\n    let flow = Flow::CustomersDelete;\n    let payload = web::Json(customers::CustomerId {\n        customer_id: path.into_inner(),\n    })\n    .into_inner();\n\n    Box::pin(api::server_wrap(\n        flow,\n        state,\n        &req,\n        payload,\n        |state, auth: auth::AuthenticationData, req, _| {\n            delete_customer(state, auth.merchant_account, req, auth.key_store)\n        },\n        auth::auth_type(",
+        "after": ") -> impl Responder {\n    let flow = Flow::CustomersDelete;\n    let customer_id = path.into_inner();\n\n    Box::pin(api::server_wrap(\n        flow,\n        state,\n        &req,\n        customer_id,\n        |state, auth: auth::AuthenticationData, customer_id, _| {\n            delete_customer(state, auth.merchant_account, customer_id, auth.key_store)\n        },\n        auth::auth_type("
+      },
+      "commit_sha": "61d72906a8114a720b985f1dc50b2b087d22554a"
+    },
+    {
+      "id": "crates/router/src/types/api/customers.rs::impl::CustomerResponse",
+      "file": "crates/router/src/types/api/customers.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": false,
+      "imports_changed": true,
+      "before_code": "impl ForeignFrom<customer::Customer> for CustomerResponse {\n    fn foreign_from(cust: domain::Customer) -> Self {\n        customers::CustomerResponse {\n            merchant_reference_id: cust.merchant_reference_id,\n            name: cust.name,\n            email: cust.email,\n            phone: cust.phone,\n            phone_country_code: cust.phone_country_code,\n            description: cust.description,\n            created_at: cust.created_at,\n            metadata: cust.metadata,\n            default_billing_address: None,\n            default_shipping_address: None,\n            default_payment_method_id: cust.default_payment_method_id,\n            id: cust.id,\n        }\n        .into()\n    }\n}",
+      "after_code": "impl ForeignFrom<customer::Customer> for CustomerResponse {\n    fn foreign_from(cust: domain::Customer) -> Self {\n        customers::CustomerResponse {\n            merchant_reference_id: cust.merchant_reference_id,\n            name: cust.name,\n            email: cust.email,\n            phone: cust.phone,\n            phone_country_code: cust.phone_country_code,\n            description: cust.description,\n            created_at: cust.created_at,\n            metadata: cust.metadata,\n            default_billing_address: None,\n            default_shipping_address: None,\n            default_payment_method_id: cust.default_payment_method_id,\n            id: cust.id,\n        }\n        .into()\n    }\n}",
+      "diff_span": {
+        "before": "",
+        "after": ""
+      },
+      "commit_sha": "61d72906a8114a720b985f1dc50b2b087d22554a",
+      "before_imports": [
+        "use hyperswitch_domain_models::customer;",
+        "use api_models::customers;",
+        "pub use api_models::customers::{\n    CustomerDeleteResponse, CustomerId, CustomerListRequest, CustomerRequest,\n    CustomerUpdateRequest, CustomerUpdateRequestInternal,\n};",
+        "use crate::{\n    newtype,\n    types::{domain, ForeignFrom},\n};"
+      ],
+      "after_imports": [
+        "use hyperswitch_domain_models::customer;",
+        "use api_models::customers;",
+        "use crate::{\n    newtype,\n    types::{domain, ForeignFrom},\n};",
+        "pub use api_models::customers::{\n    CustomerDeleteResponse, CustomerListRequest, CustomerRequest, CustomerUpdateRequest,\n    CustomerUpdateRequestInternal,\n};"
+      ]
+    },
+    {
+      "id": "crates/router/src/core/customers.rs::impl::id_type::CustomerId",
+      "file": "crates/router/src/core/customers.rs",
+      "kind": "impl_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "impl CustomerDeleteBridge for id_type::CustomerId {\n    async fn fetch_domain_model_and_update_and_generate_delete_customer_response<'a>(\n        &'a self,\n        db: &'a dyn StorageInterface,\n        key_store: &'a domain::MerchantKeyStore,\n        merchant_account: &'a domain::MerchantAccount,\n        key_manager_state: &'a KeyManagerState,\n        state: &'a SessionState,\n    ) -> errors::CustomerResponse<customers::CustomerDeleteResponse> {\n        let customer_orig = db\n            .find_customer_by_customer_id_merchant_id(\n                key_manager_state,\n                self,\n                merchant_account.get_id(),\n                key_store,\n                merchant_account.storage_scheme,\n            )\n            .await\n            .switch()?;\n\n        let customer_mandates = db\n            .find_mandate_by_merchant_id_customer_id(merchant_account.get_id(), self)\n            .await\n            .switch()?;\n\n        for mandate in customer_mandates.into_iter() {\n            if mandate.mandate_status == enums::MandateStatus::Active {\n                Err(errors::CustomersErrorResponse::MandateActive)?\n            }\n        }\n\n        match db\n            .find_payment_method_by_customer_id_merchant_id_list(\n                key_manager_state,\n                key_store,\n                self,\n                merchant_account.get_id(),\n                None,\n            )\n            .await\n        {\n            // check this in review\n            Ok(customer_payment_methods) => {\n                for pm in customer_payment_methods.into_iter() {\n                    if pm.get_payment_method_type() == Some(enums::PaymentMethod::Card) {\n                        cards::delete_card_from_locker(\n                            state,\n                            self,\n                            merchant_account.get_id(),\n                            pm.locker_id.as_ref().unwrap_or(&pm.payment_method_id),\n                        )\n                        .await\n                        .switch()?;\n\n                        if let Some(network_token_ref_id) = pm.network_token_requestor_reference_id\n                        {\n                            network_tokenization::delete_network_token_from_locker_and_token_service(\n                            state,\n                            self,\n                            merchant_account.get_id(),\n                            pm.payment_method_id.clone(),\n                            pm.network_token_locker_id,\n                            network_token_ref_id,\n                        )\n                        .await\n                        .switch()?;\n                        }\n                    }\n\n                    db.delete_payment_method_by_merchant_id_payment_method_id(\n                        key_manager_state,\n                        key_store,\n                        merchant_account.get_id(),\n                        &pm.payment_method_id,\n                    )\n                    .await\n                    .switch()?;\n                }\n            }\n            Err(error) => {\n                if error.current_context().is_db_not_found() {\n                    Ok(())\n                } else {\n                    Err(error)\n                        .change_context(errors::CustomersErrorResponse::InternalServerError)\n                        .attach_printable(\n                            \"failed find_payment_method_by_customer_id_merchant_id_list\",\n                        )\n                }?\n            }\n        };\n\n        let key = key_store.key.get_inner().peek();\n        let identifier = Identifier::Merchant(key_store.merchant_id.clone());\n        let redacted_encrypted_value: Encryptable<Secret<_>> = types::crypto_operation(\n            key_manager_state,\n            type_name!(storage::Address),\n            types::CryptoOperation::Encrypt(REDACTED.to_string().into()),\n            identifier.clone(),\n            key,\n        )\n        .await\n        .and_then(|val| val.try_into_operation())\n        .switch()?;\n\n        let redacted_encrypted_email = Encryptable::new(\n            redacted_encrypted_value\n                .clone()\n                .into_inner()\n                .switch_strategy(),\n            redacted_encrypted_value.clone().into_encrypted(),\n        );\n\n        let update_address = storage::AddressUpdate::Update {\n            city: Some(REDACTED.to_string()),\n            country: None,\n            line1: Some(redacted_encrypted_value.clone()),\n            line2: Some(redacted_encrypted_value.clone()),\n            line3: Some(redacted_encrypted_value.clone()),\n            state: Some(redacted_encrypted_value.clone()),\n            zip: Some(redacted_encrypted_value.clone()),\n            first_name: Some(redacted_encrypted_value.clone()),\n            last_name: Some(redacted_encrypted_value.clone()),\n            phone_number: Some(redacted_encrypted_value.clone()),\n            country_code: Some(REDACTED.to_string()),\n            updated_by: merchant_account.storage_scheme.to_string(),\n            email: Some(redacted_encrypted_email),\n        };\n\n        match db\n            .update_address_by_merchant_id_customer_id(\n                key_manager_state,\n                self,\n                merchant_account.get_id(),\n                update_address,\n                key_store,\n            )\n            .await\n        {\n            Ok(_) => Ok(()),\n            Err(error) => {\n                if error.current_context().is_db_not_found() {\n                    Ok(())\n                } else {\n                    Err(error)\n                        .change_context(errors::CustomersErrorResponse::InternalServerError)\n                        .attach_printable(\"failed update_address_by_merchant_id_customer_id\")\n                }\n            }\n        }?;\n\n        let updated_customer = storage::CustomerUpdate::Update {\n            name: Some(redacted_encrypted_value.clone()),\n            email: Some(\n                types::crypto_operation(\n                    key_manager_state,\n                    type_name!(storage::Customer),\n                    types::CryptoOperation::Encrypt(REDACTED.to_string().into()),\n                    identifier,\n                    key,\n                )\n                .await\n                .and_then(|val| val.try_into_operation())\n                .switch()?,\n            ),\n            phone: Box::new(Some(redacted_encrypted_value.clone())),\n            description: Some(Description::from_str_unchecked(REDACTED)),\n            phone_country_code: Some(REDACTED.to_string()),\n            metadata: None,\n            connector_customer: Box::new(None),\n            address_id: None,\n        };\n\n        db.update_customer_by_customer_id_merchant_id(\n            key_manager_state,\n            self.clone(),\n            merchant_account.get_id().to_owned(),\n            customer_orig,\n            updated_customer,\n            key_store,\n            merchant_account.storage_scheme,\n        )\n        .await\n        .switch()?;\n\n        let response = customers::CustomerDeleteResponse {\n            customer_id: self.clone(),\n            customer_deleted: true,\n            address_deleted: true,\n            payment_methods_deleted: true,\n        };\n        metrics::CUSTOMER_REDACTED.add(1, &[]);\n        Ok(services::ApplicationResponse::Json(response))\n    }\n}",
+      "diff_span": null,
+      "commit_sha": "61d72906a8114a720b985f1dc50b2b087d22554a"
+    },
+    {
+      "id": "crates/common_utils/src/id_type/customer.rs::impl::CustomerId",
+      "file": "crates/common_utils/src/id_type/customer.rs",
+      "kind": "impl_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "impl crate::events::ApiEventMetric for CustomerId {\n    fn get_api_event_type(&self) -> Option<crate::events::ApiEventsType> {\n        Some(crate::events::ApiEventsType::Customer {\n            customer_id: self.clone(),\n        })\n    }\n}",
+      "diff_span": null,
+      "commit_sha": "61d72906a8114a720b985f1dc50b2b087d22554a"
+    },
+    {
+      "id": "crates/router/src/core/customers.rs::id_type::CustomerId::function::fetch_domain_model_and_update_and_generate_delete_customer_response",
+      "file": "crates/router/src/core/customers.rs",
+      "kind": "function_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "async fn fetch_domain_model_and_update_and_generate_delete_customer_response<'a>(\n        &'a self,\n        db: &'a dyn StorageInterface,\n        key_store: &'a domain::MerchantKeyStore,\n        merchant_account: &'a domain::MerchantAccount,\n        key_manager_state: &'a KeyManagerState,\n        state: &'a SessionState,\n    ) -> errors::CustomerResponse<customers::CustomerDeleteResponse> {\n        let customer_orig = db\n            .find_customer_by_customer_id_merchant_id(\n                key_manager_state,\n                self,\n                merchant_account.get_id(),\n                key_store,\n                merchant_account.storage_scheme,\n            )\n            .await\n            .switch()?;\n\n        let customer_mandates = db\n            .find_mandate_by_merchant_id_customer_id(merchant_account.get_id(), self)\n            .await\n            .switch()?;\n\n        for mandate in customer_mandates.into_iter() {\n            if mandate.mandate_status == enums::MandateStatus::Active {\n                Err(errors::CustomersErrorResponse::MandateActive)?\n            }\n        }\n\n        match db\n            .find_payment_method_by_customer_id_merchant_id_list(\n                key_manager_state,\n                key_store,\n                self,\n                merchant_account.get_id(),\n                None,\n            )\n            .await\n        {\n            // check this in review\n            Ok(customer_payment_methods) => {\n                for pm in customer_payment_methods.into_iter() {\n                    if pm.get_payment_method_type() == Some(enums::PaymentMethod::Card) {\n                        cards::delete_card_from_locker(\n                            state,\n                            self,\n                            merchant_account.get_id(),\n                            pm.locker_id.as_ref().unwrap_or(&pm.payment_method_id),\n                        )\n                        .await\n                        .switch()?;\n\n                        if let Some(network_token_ref_id) = pm.network_token_requestor_reference_id\n                        {\n                            network_tokenization::delete_network_token_from_locker_and_token_service(\n                            state,\n                            self,\n                            merchant_account.get_id(),\n                            pm.payment_method_id.clone(),\n                            pm.network_token_locker_id,\n                            network_token_ref_id,\n                        )\n                        .await\n                        .switch()?;\n                        }\n                    }\n\n                    db.delete_payment_method_by_merchant_id_payment_method_id(\n                        key_manager_state,\n                        key_store,\n                        merchant_account.get_id(),\n                        &pm.payment_method_id,\n                    )\n                    .await\n                    .switch()?;\n                }\n            }\n            Err(error) => {\n                if error.current_context().is_db_not_found() {\n                    Ok(())\n                } else {\n                    Err(error)\n                        .change_context(errors::CustomersErrorResponse::InternalServerError)\n                        .attach_printable(\n                            \"failed find_payment_method_by_customer_id_merchant_id_list\",\n                        )\n                }?\n            }\n        };\n\n        let key = key_store.key.get_inner().peek();\n        let identifier = Identifier::Merchant(key_store.merchant_id.clone());\n        let redacted_encrypted_value: Encryptable<Secret<_>> = types::crypto_operation(\n            key_manager_state,\n            type_name!(storage::Address),\n            types::CryptoOperation::Encrypt(REDACTED.to_string().into()),\n            identifier.clone(),\n            key,\n        )\n        .await\n        .and_then(|val| val.try_into_operation())\n        .switch()?;\n\n        let redacted_encrypted_email = Encryptable::new(\n            redacted_encrypted_value\n                .clone()\n                .into_inner()\n                .switch_strategy(),\n            redacted_encrypted_value.clone().into_encrypted(),\n        );\n\n        let update_address = storage::AddressUpdate::Update {\n            city: Some(REDACTED.to_string()),\n            country: None,\n            line1: Some(redacted_encrypted_value.clone()),\n            line2: Some(redacted_encrypted_value.clone()),\n            line3: Some(redacted_encrypted_value.clone()),\n            state: Some(redacted_encrypted_value.clone()),\n            zip: Some(redacted_encrypted_value.clone()),\n            first_name: Some(redacted_encrypted_value.clone()),\n            last_name: Some(redacted_encrypted_value.clone()),\n            phone_number: Some(redacted_encrypted_value.clone()),\n            country_code: Some(REDACTED.to_string()),\n            updated_by: merchant_account.storage_scheme.to_string(),\n            email: Some(redacted_encrypted_email),\n        };\n\n        match db\n            .update_address_by_merchant_id_customer_id(\n                key_manager_state,\n                self,\n                merchant_account.get_id(),\n                update_address,\n                key_store,\n            )\n            .await\n        {\n            Ok(_) => Ok(()),\n            Err(error) => {\n                if error.current_context().is_db_not_found() {\n                    Ok(())\n                } else {\n                    Err(error)\n                        .change_context(errors::CustomersErrorResponse::InternalServerError)\n                        .attach_printable(\"failed update_address_by_merchant_id_customer_id\")\n                }\n            }\n        }?;\n\n        let updated_customer = storage::CustomerUpdate::Update {\n            name: Some(redacted_encrypted_value.clone()),\n            email: Some(\n                types::crypto_operation(\n                    key_manager_state,\n                    type_name!(storage::Customer),\n                    types::CryptoOperation::Encrypt(REDACTED.to_string().into()),\n                    identifier,\n                    key,\n                )\n                .await\n                .and_then(|val| val.try_into_operation())\n                .switch()?,\n            ),\n            phone: Box::new(Some(redacted_encrypted_value.clone())),\n            description: Some(Description::from_str_unchecked(REDACTED)),\n            phone_country_code: Some(REDACTED.to_string()),\n            metadata: None,\n            connector_customer: Box::new(None),\n            address_id: None,\n        };\n\n        db.update_customer_by_customer_id_merchant_id(\n            key_manager_state,\n            self.clone(),\n            merchant_account.get_id().to_owned(),\n            customer_orig,\n            updated_customer,\n            key_store,\n            merchant_account.storage_scheme,\n        )\n        .await\n        .switch()?;\n\n        let response = customers::CustomerDeleteResponse {\n            customer_id: self.clone(),\n            customer_deleted: true,\n            address_deleted: true,\n            payment_methods_deleted: true,\n        };\n        metrics::CUSTOMER_REDACTED.add(1, &[]);\n        Ok(services::ApplicationResponse::Json(response))\n    }",
+      "diff_span": null,
+      "commit_sha": "61d72906a8114a720b985f1dc50b2b087d22554a"
+    },
+    {
+      "id": "crates/common_utils/src/id_type/customer.rs::CustomerId::function::get_api_event_type",
+      "file": "crates/common_utils/src/id_type/customer.rs",
+      "kind": "function_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "fn get_api_event_type(&self) -> Option<crate::events::ApiEventsType> {\n        Some(crate::events::ApiEventsType::Customer {\n            customer_id: self.clone(),\n        })\n    }",
+      "diff_span": null,
+      "commit_sha": "61d72906a8114a720b985f1dc50b2b087d22554a"
+    },
+    {
+      "id": "crates/api_models/src/customers.rs::impl::CustomerId",
+      "file": "crates/api_models/src/customers.rs",
+      "kind": "impl_item",
+      "status": "removed",
+      "before_code": "impl CustomerId {\n    pub fn get_merchant_reference_id(&self) -> id_type::CustomerId {\n        self.merchant_reference_id.clone()\n    }\n\n    pub fn new_customer_id_struct(cust: id_type::CustomerId) -> Self {\n        Self {\n            merchant_reference_id: cust,\n        }\n    }\n}",
+      "after_code": null,
+      "diff_span": null,
+      "commit_sha": "61d72906a8114a720b985f1dc50b2b087d22554a"
+    },
+    {
+      "id": "crates/router/src/core/customers.rs::impl::customers::CustomerId",
+      "file": "crates/router/src/core/customers.rs",
+      "kind": "impl_item",
+      "status": "removed",
+      "before_code": "impl CustomerDeleteBridge for customers::CustomerId {\n    async fn fetch_domain_model_and_update_and_generate_delete_customer_response<'a>(\n        &'a self,\n        db: &'a dyn StorageInterface,\n        key_store: &'a domain::MerchantKeyStore,\n        merchant_account: &'a domain::MerchantAccount,\n        key_manager_state: &'a KeyManagerState,\n        state: &'a SessionState,\n    ) -> errors::CustomerResponse<customers::CustomerDeleteResponse> {\n        let customer_orig = db\n            .find_customer_by_customer_id_merchant_id(\n                key_manager_state,\n                &self.customer_id,\n                merchant_account.get_id(),\n                key_store,\n                merchant_account.storage_scheme,\n            )\n            .await\n            .switch()?;\n\n        let customer_mandates = db\n            .find_mandate_by_merchant_id_customer_id(merchant_account.get_id(), &self.customer_id)\n            .await\n            .switch()?;\n\n        for mandate in customer_mandates.into_iter() {\n            if mandate.mandate_status == enums::MandateStatus::Active {\n                Err(errors::CustomersErrorResponse::MandateActive)?\n            }\n        }\n\n        match db\n            .find_payment_method_by_customer_id_merchant_id_list(\n                key_manager_state,\n                key_store,\n                &self.customer_id,\n                merchant_account.get_id(),\n                None,\n            )\n            .await\n        {\n            // check this in review\n            Ok(customer_payment_methods) => {\n                for pm in customer_payment_methods.into_iter() {\n                    if pm.get_payment_method_type() == Some(enums::PaymentMethod::Card) {\n                        cards::delete_card_from_locker(\n                            state,\n                            &self.customer_id,\n                            merchant_account.get_id(),\n                            pm.locker_id.as_ref().unwrap_or(&pm.payment_method_id),\n                        )\n                        .await\n                        .switch()?;\n\n                        if let Some(network_token_ref_id) = pm.network_token_requestor_reference_id\n                        {\n                            network_tokenization::delete_network_token_from_locker_and_token_service(\n                            state,\n                            &self.customer_id,\n                            merchant_account.get_id(),\n                            pm.payment_method_id.clone(),\n                            pm.network_token_locker_id,\n                            network_token_ref_id,\n                        )\n                        .await\n                        .switch()?;\n                        }\n                    }\n\n                    db.delete_payment_method_by_merchant_id_payment_method_id(\n                        key_manager_state,\n                        key_store,\n                        merchant_account.get_id(),\n                        &pm.payment_method_id,\n                    )\n                    .await\n                    .switch()?;\n                }\n            }\n            Err(error) => {\n                if error.current_context().is_db_not_found() {\n                    Ok(())\n                } else {\n                    Err(error)\n                        .change_context(errors::CustomersErrorResponse::InternalServerError)\n                        .attach_printable(\n                            \"failed find_payment_method_by_customer_id_merchant_id_list\",\n                        )\n                }?\n            }\n        };\n\n        let key = key_store.key.get_inner().peek();\n        let identifier = Identifier::Merchant(key_store.merchant_id.clone());\n        let redacted_encrypted_value: Encryptable<Secret<_>> = types::crypto_operation(\n            key_manager_state,\n            type_name!(storage::Address),\n            types::CryptoOperation::Encrypt(REDACTED.to_string().into()),\n            identifier.clone(),\n            key,\n        )\n        .await\n        .and_then(|val| val.try_into_operation())\n        .switch()?;\n\n        let redacted_encrypted_email = Encryptable::new(\n            redacted_encrypted_value\n                .clone()\n                .into_inner()\n                .switch_strategy(),\n            redacted_encrypted_value.clone().into_encrypted(),\n        );\n\n        let update_address = storage::AddressUpdate::Update {\n            city: Some(REDACTED.to_string()),\n            country: None,\n            line1: Some(redacted_encrypted_value.clone()),\n            line2: Some(redacted_encrypted_value.clone()),\n            line3: Some(redacted_encrypted_value.clone()),\n            state: Some(redacted_encrypted_value.clone()),\n            zip: Some(redacted_encrypted_value.clone()),\n            first_name: Some(redacted_encrypted_value.clone()),\n            last_name: Some(redacted_encrypted_value.clone()),\n            phone_number: Some(redacted_encrypted_value.clone()),\n            country_code: Some(REDACTED.to_string()),\n            updated_by: merchant_account.storage_scheme.to_string(),\n            email: Some(redacted_encrypted_email),\n        };\n\n        match db\n            .update_address_by_merchant_id_customer_id(\n                key_manager_state,\n                &self.customer_id,\n                merchant_account.get_id(),\n                update_address,\n                key_store,\n            )\n            .await\n        {\n            Ok(_) => Ok(()),\n            Err(error) => {\n                if error.current_context().is_db_not_found() {\n                    Ok(())\n                } else {\n                    Err(error)\n                        .change_context(errors::CustomersErrorResponse::InternalServerError)\n                        .attach_printable(\"failed update_address_by_merchant_id_customer_id\")\n                }\n            }\n        }?;\n\n        let updated_customer = storage::CustomerUpdate::Update {\n            name: Some(redacted_encrypted_value.clone()),\n            email: Some(\n                types::crypto_operation(\n                    key_manager_state,\n                    type_name!(storage::Customer),\n                    types::CryptoOperation::Encrypt(REDACTED.to_string().into()),\n                    identifier,\n                    key,\n                )\n                .await\n                .and_then(|val| val.try_into_operation())\n                .switch()?,\n            ),\n            phone: Box::new(Some(redacted_encrypted_value.clone())),\n            description: Some(Description::from_str_unchecked(REDACTED)),\n            phone_country_code: Some(REDACTED.to_string()),\n            metadata: None,\n            connector_customer: Box::new(None),\n            address_id: None,\n        };\n\n        db.update_customer_by_customer_id_merchant_id(\n            key_manager_state,\n            self.customer_id.clone(),\n            merchant_account.get_id().to_owned(),\n            customer_orig,\n            updated_customer,\n            key_store,\n            merchant_account.storage_scheme,\n        )\n        .await\n        .switch()?;\n\n        let response = customers::CustomerDeleteResponse {\n            customer_id: self.customer_id.clone(),\n            customer_deleted: true,\n            address_deleted: true,\n            payment_methods_deleted: true,\n        };\n        metrics::CUSTOMER_REDACTED.add(1, &[]);\n        Ok(services::ApplicationResponse::Json(response))\n    }\n}",
+      "after_code": null,
+      "diff_span": null,
+      "commit_sha": "61d72906a8114a720b985f1dc50b2b087d22554a"
+    },
+    {
+      "id": "crates/api_models/src/events/customer.rs::impl::CustomerId",
+      "file": "crates/api_models/src/events/customer.rs",
+      "kind": "impl_item",
+      "status": "removed",
+      "before_code": "impl ApiEventMetric for CustomerId {\n    fn get_api_event_type(&self) -> Option<ApiEventsType> {\n        Some(ApiEventsType::Customer {\n            customer_id: self.get_merchant_reference_id().clone(),\n        })\n    }\n}",
+      "after_code": null,
+      "diff_span": null,
+      "commit_sha": "61d72906a8114a720b985f1dc50b2b087d22554a"
+    },
+    {
+      "id": "crates/api_models/src/events/customer.rs::CustomerId::function::get_api_event_type",
+      "file": "crates/api_models/src/events/customer.rs",
+      "kind": "function_item",
+      "status": "removed",
+      "before_code": "fn get_api_event_type(&self) -> Option<ApiEventsType> {\n        Some(ApiEventsType::Customer {\n            customer_id: self.get_merchant_reference_id().clone(),\n        })\n    }",
+      "after_code": null,
+      "diff_span": null,
+      "commit_sha": "61d72906a8114a720b985f1dc50b2b087d22554a"
+    },
+    {
+      "id": "crates/api_models/src/customers.rs::CustomerId::function::new_customer_id_struct",
+      "file": "crates/api_models/src/customers.rs",
+      "kind": "function_item",
+      "status": "removed",
+      "before_code": "pub fn new_customer_id_struct(cust: id_type::CustomerId) -> Self {\n        Self {\n            merchant_reference_id: cust,\n        }\n    }",
+      "after_code": null,
+      "diff_span": null,
+      "commit_sha": "61d72906a8114a720b985f1dc50b2b087d22554a"
+    },
+    {
+      "id": "crates/router/src/core/customers.rs::customers::CustomerId::function::fetch_domain_model_and_update_and_generate_delete_customer_response",
+      "file": "crates/router/src/core/customers.rs",
+      "kind": "function_item",
+      "status": "removed",
+      "before_code": "async fn fetch_domain_model_and_update_and_generate_delete_customer_response<'a>(\n        &'a self,\n        db: &'a dyn StorageInterface,\n        key_store: &'a domain::MerchantKeyStore,\n        merchant_account: &'a domain::MerchantAccount,\n        key_manager_state: &'a KeyManagerState,\n        state: &'a SessionState,\n    ) -> errors::CustomerResponse<customers::CustomerDeleteResponse> {\n        let customer_orig = db\n            .find_customer_by_customer_id_merchant_id(\n                key_manager_state,\n                &self.customer_id,\n                merchant_account.get_id(),\n                key_store,\n                merchant_account.storage_scheme,\n            )\n            .await\n            .switch()?;\n\n        let customer_mandates = db\n            .find_mandate_by_merchant_id_customer_id(merchant_account.get_id(), &self.customer_id)\n            .await\n            .switch()?;\n\n        for mandate in customer_mandates.into_iter() {\n            if mandate.mandate_status == enums::MandateStatus::Active {\n                Err(errors::CustomersErrorResponse::MandateActive)?\n            }\n        }\n\n        match db\n            .find_payment_method_by_customer_id_merchant_id_list(\n                key_manager_state,\n                key_store,\n                &self.customer_id,\n                merchant_account.get_id(),\n                None,\n            )\n            .await\n        {\n            // check this in review\n            Ok(customer_payment_methods) => {\n                for pm in customer_payment_methods.into_iter() {\n                    if pm.get_payment_method_type() == Some(enums::PaymentMethod::Card) {\n                        cards::delete_card_from_locker(\n                            state,\n                            &self.customer_id,\n                            merchant_account.get_id(),\n                            pm.locker_id.as_ref().unwrap_or(&pm.payment_method_id),\n                        )\n                        .await\n                        .switch()?;\n\n                        if let Some(network_token_ref_id) = pm.network_token_requestor_reference_id\n                        {\n                            network_tokenization::delete_network_token_from_locker_and_token_service(\n                            state,\n                            &self.customer_id,\n                            merchant_account.get_id(),\n                            pm.payment_method_id.clone(),\n                            pm.network_token_locker_id,\n                            network_token_ref_id,\n                        )\n                        .await\n                        .switch()?;\n                        }\n                    }\n\n                    db.delete_payment_method_by_merchant_id_payment_method_id(\n                        key_manager_state,\n                        key_store,\n                        merchant_account.get_id(),\n                        &pm.payment_method_id,\n                    )\n                    .await\n                    .switch()?;\n                }\n            }\n            Err(error) => {\n                if error.current_context().is_db_not_found() {\n                    Ok(())\n                } else {\n                    Err(error)\n                        .change_context(errors::CustomersErrorResponse::InternalServerError)\n                        .attach_printable(\n                            \"failed find_payment_method_by_customer_id_merchant_id_list\",\n                        )\n                }?\n            }\n        };\n\n        let key = key_store.key.get_inner().peek();\n        let identifier = Identifier::Merchant(key_store.merchant_id.clone());\n        let redacted_encrypted_value: Encryptable<Secret<_>> = types::crypto_operation(\n            key_manager_state,\n            type_name!(storage::Address),\n            types::CryptoOperation::Encrypt(REDACTED.to_string().into()),\n            identifier.clone(),\n            key,\n        )\n        .await\n        .and_then(|val| val.try_into_operation())\n        .switch()?;\n\n        let redacted_encrypted_email = Encryptable::new(\n            redacted_encrypted_value\n                .clone()\n                .into_inner()\n                .switch_strategy(),\n            redacted_encrypted_value.clone().into_encrypted(),\n        );\n\n        let update_address = storage::AddressUpdate::Update {\n            city: Some(REDACTED.to_string()),\n            country: None,\n            line1: Some(redacted_encrypted_value.clone()),\n            line2: Some(redacted_encrypted_value.clone()),\n            line3: Some(redacted_encrypted_value.clone()),\n            state: Some(redacted_encrypted_value.clone()),\n            zip: Some(redacted_encrypted_value.clone()),\n            first_name: Some(redacted_encrypted_value.clone()),\n            last_name: Some(redacted_encrypted_value.clone()),\n            phone_number: Some(redacted_encrypted_value.clone()),\n            country_code: Some(REDACTED.to_string()),\n            updated_by: merchant_account.storage_scheme.to_string(),\n            email: Some(redacted_encrypted_email),\n        };\n\n        match db\n            .update_address_by_merchant_id_customer_id(\n                key_manager_state,\n                &self.customer_id,\n                merchant_account.get_id(),\n                update_address,\n                key_store,\n            )\n            .await\n        {\n            Ok(_) => Ok(()),\n            Err(error) => {\n                if error.current_context().is_db_not_found() {\n                    Ok(())\n                } else {\n                    Err(error)\n                        .change_context(errors::CustomersErrorResponse::InternalServerError)\n                        .attach_printable(\"failed update_address_by_merchant_id_customer_id\")\n                }\n            }\n        }?;\n\n        let updated_customer = storage::CustomerUpdate::Update {\n            name: Some(redacted_encrypted_value.clone()),\n            email: Some(\n                types::crypto_operation(\n                    key_manager_state,\n                    type_name!(storage::Customer),\n                    types::CryptoOperation::Encrypt(REDACTED.to_string().into()),\n                    identifier,\n                    key,\n                )\n                .await\n                .and_then(|val| val.try_into_operation())\n                .switch()?,\n            ),\n            phone: Box::new(Some(redacted_encrypted_value.clone())),\n            description: Some(Description::from_str_unchecked(REDACTED)),\n            phone_country_code: Some(REDACTED.to_string()),\n            metadata: None,\n            connector_customer: Box::new(None),\n            address_id: None,\n        };\n\n        db.update_customer_by_customer_id_merchant_id(\n            key_manager_state,\n            self.customer_id.clone(),\n            merchant_account.get_id().to_owned(),\n            customer_orig,\n            updated_customer,\n            key_store,\n            merchant_account.storage_scheme,\n        )\n        .await\n        .switch()?;\n\n        let response = customers::CustomerDeleteResponse {\n            customer_id: self.customer_id.clone(),\n            customer_deleted: true,\n            address_deleted: true,\n            payment_methods_deleted: true,\n        };\n        metrics::CUSTOMER_REDACTED.add(1, &[]);\n        Ok(services::ApplicationResponse::Json(response))\n    }",
+      "after_code": null,
+      "diff_span": null,
+      "commit_sha": "61d72906a8114a720b985f1dc50b2b087d22554a"
+    },
+    {
+      "id": "crates/api_models/src/customers.rs::CustomerId::function::get_merchant_reference_id",
+      "file": "crates/api_models/src/customers.rs",
+      "kind": "function_item",
+      "status": "removed",
+      "before_code": "pub fn get_merchant_reference_id(&self) -> id_type::CustomerId {\n        self.merchant_reference_id.clone()\n    }",
+      "after_code": null,
+      "diff_span": null,
+      "commit_sha": "61d72906a8114a720b985f1dc50b2b087d22554a"
+    },
+    {
+      "id": "crates/api_models/src/customers.rs::struct::CustomerId",
+      "file": "crates/api_models/src/customers.rs",
+      "kind": "struct_item",
+      "status": "removed",
+      "before_code": "pub struct CustomerId {\n    pub merchant_reference_id: id_type::CustomerId,\n}",
+      "after_code": null,
+      "diff_span": null,
+      "commit_sha": "61d72906a8114a720b985f1dc50b2b087d22554a"
+    }
+  ]
+}

diffs/pr_6836/b3a0297/diff.json

@@ -0,0 +1,85 @@
+{
+  "commit_sha": "b3a029767505b8dff53e38844bb5c1c559570f43",
+  "pr_number": 6836,
+  "rust_files": [
+    "crates/api_models/src/payment_methods.rs",
+    "crates/api_models/src/payments.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/api_models/src/payments.rs::struct::PaymentsIntentResponse",
+      "file": "crates/api_models/src/payments.rs",
+      "kind": "struct_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub struct PaymentsIntentResponse {\n    /// Global Payment Id for the payment\n    #[schema(value_type = String)]\n    pub id: id_type::GlobalPaymentId,\n\n    /// The status of the payment\n    #[schema(value_type = IntentStatus, example = \"succeeded\")]\n    pub status: common_enums::IntentStatus,\n\n    /// The amount details for the payment\n    pub amount_details: AmountDetailsResponse,\n\n    /// It's a token used for client side verification.\n    #[schema(value_type = String, example = \"pay_U42c409qyHwOkWo3vK60_secret_el9ksDkiB8hi6j9N78yo\")]\n    pub client_secret: common_utils::types::ClientSecret,\n\n    /// The identifier for the profile. This is inferred from the `x-profile-id` header\n    #[schema(value_type = String)]\n    pub profile_id: id_type::ProfileId,\n\n    /// Unique identifier for the payment. This ensures idempotency for multiple payments\n    /// that have been done by a single merchant.\n    #[schema(\n        value_type = Option<String>,\n        min_length = 30,\n        max_length = 30,\n        example = \"pay_mbabizu24mvu3mela5njyhpit4\"\n    )]\n    pub merchant_reference_id: Option<id_type::PaymentReferenceId>,\n\n    /// The routing algorithm id to be used for the payment\n    #[schema(value_type = Option<String>)]\n    pub routing_algorithm_id: Option<id_type::RoutingId>,\n\n    #[schema(value_type = CaptureMethod, example = \"automatic\")]\n    pub capture_method: api_enums::CaptureMethod,\n\n    #[schema(value_type = AuthenticationType, example = \"no_three_ds\", default = \"no_three_ds\")]\n    pub authentication_type: api_enums::AuthenticationType,\n\n    /// The billing details of the payment. This address will be used for invoicing.\n    #[schema(value_type = Option<Address>)]\n    pub billing: Option<Address>,\n\n    /// The shipping address for the payment\n    #[schema(value_type = Option<Address>)]\n    pub shipping: Option<Address>,\n\n    /// The identifier for the customer\n    #[schema(value_type = Option<String>, max_length = 64, min_length = 1, example = \"cus_y3oqhf46pyzuxjbcn2giaqnb44\")]\n    pub customer_id: Option<id_type::GlobalCustomerId>,\n\n    /// Set to `present` to indicate that the customer is in your checkout flow during this payment, and therefore is able to authenticate. This parameter should be `absent` when merchant's doing merchant initiated payments and customer is not present while doing the payment.\n    #[schema(example = \"present\", value_type = PresenceOfCustomerDuringPayment)]\n    pub customer_present: common_enums::PresenceOfCustomerDuringPayment,\n\n    /// A description for the payment\n    #[schema(example = \"It's my first payment request\", value_type = Option<String>)]\n    pub description: Option<common_utils::types::Description>,\n\n    /// The URL to which you want the user to be redirected after the completion of the payment operation\n    #[schema(value_type = Option<String>, example = \"https://hyperswitch.io\")]\n    pub return_url: Option<common_utils::types::Url>,\n\n    #[schema(value_type = FutureUsage, example = \"off_session\")]\n    pub setup_future_usage: api_enums::FutureUsage,\n\n    /// Apply MIT exemption for a payment\n    #[schema(value_type = MitExemptionRequest)]\n    pub apply_mit_exemption: common_enums::MitExemptionRequest,\n\n    /// For non-card charges, you can use this value as the complete description that appears on your customers\u2019 statements. Must contain at least one letter, maximum 22 characters.\n    #[schema(max_length = 22, example = \"Hyperswitch Router\", value_type = Option<String>)]\n    pub statement_descriptor: Option<common_utils::types::StatementDescriptor>,\n\n    /// Use this object to capture the details about the different products for which the payment is being made. The sum of amount across different products here should be equal to the overall payment amount\n    #[schema(value_type = Option<Vec<OrderDetailsWithAmount>>, example = r#\"[{\n        \"product_name\": \"Apple iPhone 16\",\n        \"quantity\": 1,\n        \"amount\" : 69000\n        \"product_img_link\" : \"https://dummy-img-link.com\"\n    }]\"#)]\n    pub order_details: Option<Vec<OrderDetailsWithAmount>>,\n\n    /// Use this parameter to restrict the Payment Method Types to show for a given PaymentIntent\n    #[schema(value_type = Option<Vec<PaymentMethodType>>)]\n    pub allowed_payment_method_types: Option<Vec<api_enums::PaymentMethodType>>,\n\n    /// Metadata is useful for storing additional, unstructured information on an object.\n    #[schema(value_type = Option<Object>, example = r#\"{ \"udf1\": \"some-value\", \"udf2\": \"some-value\" }\"#)]\n    pub metadata: Option<pii::SecretSerdeValue>,\n\n    /// Some connectors like Apple pay, Airwallex and Noon might require some additional information, find specific details in the child attributes below.\n    #[schema(value_type = Option<ConnectorMetadata>)]\n    pub connector_metadata: Option<pii::SecretSerdeValue>,\n\n    /// Additional data that might be required by hyperswitch based on the requested features by the merchants.\n    #[schema(value_type = Option<FeatureMetadata>)]\n    pub feature_metadata: Option<FeatureMetadata>,\n\n    /// Whether to generate the payment link for this payment or not (if applicable)\n    #[schema(value_type = EnablePaymentLinkRequest)]\n    pub payment_link_enabled: common_enums::EnablePaymentLinkRequest,\n\n    /// Configure a custom payment link for the particular payment\n    #[schema(value_type = Option<PaymentLinkConfigRequest>)]\n    pub payment_link_config: Option<admin::PaymentLinkConfigRequest>,\n\n    ///Request an incremental authorization, i.e., increase the authorized amount on a confirmed payment before you capture it.\n    #[schema(value_type = RequestIncrementalAuthorization)]\n    pub request_incremental_authorization: common_enums::RequestIncrementalAuthorization,\n\n    ///Will be used to expire client secret after certain amount of time to be supplied in seconds\n    #[serde(with = \"common_utils::custom_serde::iso8601\")]\n    pub expires_on: PrimitiveDateTime,\n\n    /// Additional data related to some frm(Fraud Risk Management) connectors\n    #[schema(value_type = Option<Object>, example = r#\"{ \"coverage_request\" : \"fraud\", \"fulfillment_method\" : \"delivery\" }\"#)]\n    pub frm_metadata: Option<pii::SecretSerdeValue>,\n\n    /// Whether to perform external authentication (if applicable)\n    #[schema(value_type = External3dsAuthenticationRequest)]\n    pub request_external_three_ds_authentication: common_enums::External3dsAuthenticationRequest,\n}",
+      "after_code": "pub struct PaymentsIntentResponse {\n    /// Global Payment Id for the payment\n    #[schema(value_type = String)]\n    pub id: id_type::GlobalPaymentId,\n\n    /// The status of the payment\n    #[schema(value_type = IntentStatus, example = \"succeeded\")]\n    pub status: common_enums::IntentStatus,\n\n    /// The amount details for the payment\n    pub amount_details: AmountDetailsResponse,\n\n    /// It's a token used for client side verification.\n    #[schema(value_type = String, example = \"pay_U42c409qyHwOkWo3vK60_secret_el9ksDkiB8hi6j9N78yo\")]\n    pub client_secret: common_utils::types::ClientSecret,\n\n    /// The identifier for the profile. This is inferred from the `x-profile-id` header\n    #[schema(value_type = String)]\n    pub profile_id: id_type::ProfileId,\n\n    /// Unique identifier for the payment. This ensures idempotency for multiple payments\n    /// that have been done by a single merchant.\n    #[schema(\n        value_type = Option<String>,\n        min_length = 30,\n        max_length = 30,\n        example = \"pay_mbabizu24mvu3mela5njyhpit4\"\n    )]\n    pub merchant_reference_id: Option<id_type::PaymentReferenceId>,\n\n    /// The routing algorithm id to be used for the payment\n    #[schema(value_type = Option<String>)]\n    pub routing_algorithm_id: Option<id_type::RoutingId>,\n\n    #[schema(value_type = CaptureMethod, example = \"automatic\")]\n    pub capture_method: api_enums::CaptureMethod,\n\n    #[schema(value_type = AuthenticationType, example = \"no_three_ds\", default = \"no_three_ds\")]\n    pub authentication_type: api_enums::AuthenticationType,\n\n    /// The billing details of the payment. This address will be used for invoicing.\n    #[schema(value_type = Option<Address>)]\n    pub billing: Option<Address>,\n\n    /// The shipping address for the payment\n    #[schema(value_type = Option<Address>)]\n    pub shipping: Option<Address>,\n\n    /// The identifier for the customer\n    #[schema(\n        min_length = 32,\n        max_length = 64,\n        example = \"12345_cus_01926c58bc6e77c09e809964e72af8c8\",\n        value_type = String\n    )]\n    pub customer_id: Option<id_type::GlobalCustomerId>,\n\n    /// Set to `present` to indicate that the customer is in your checkout flow during this payment, and therefore is able to authenticate. This parameter should be `absent` when merchant's doing merchant initiated payments and customer is not present while doing the payment.\n    #[schema(example = \"present\", value_type = PresenceOfCustomerDuringPayment)]\n    pub customer_present: common_enums::PresenceOfCustomerDuringPayment,\n\n    /// A description for the payment\n    #[schema(example = \"It's my first payment request\", value_type = Option<String>)]\n    pub description: Option<common_utils::types::Description>,\n\n    /// The URL to which you want the user to be redirected after the completion of the payment operation\n    #[schema(value_type = Option<String>, example = \"https://hyperswitch.io\")]\n    pub return_url: Option<common_utils::types::Url>,\n\n    #[schema(value_type = FutureUsage, example = \"off_session\")]\n    pub setup_future_usage: api_enums::FutureUsage,\n\n    /// Apply MIT exemption for a payment\n    #[schema(value_type = MitExemptionRequest)]\n    pub apply_mit_exemption: common_enums::MitExemptionRequest,\n\n    /// For non-card charges, you can use this value as the complete description that appears on your customers\u2019 statements. Must contain at least one letter, maximum 22 characters.\n    #[schema(max_length = 22, example = \"Hyperswitch Router\", value_type = Option<String>)]\n    pub statement_descriptor: Option<common_utils::types::StatementDescriptor>,\n\n    /// Use this object to capture the details about the different products for which the payment is being made. The sum of amount across different products here should be equal to the overall payment amount\n    #[schema(value_type = Option<Vec<OrderDetailsWithAmount>>, example = r#\"[{\n        \"product_name\": \"Apple iPhone 16\",\n        \"quantity\": 1,\n        \"amount\" : 69000\n        \"product_img_link\" : \"https://dummy-img-link.com\"\n    }]\"#)]\n    pub order_details: Option<Vec<OrderDetailsWithAmount>>,\n\n    /// Use this parameter to restrict the Payment Method Types to show for a given PaymentIntent\n    #[schema(value_type = Option<Vec<PaymentMethodType>>)]\n    pub allowed_payment_method_types: Option<Vec<api_enums::PaymentMethodType>>,\n\n    /// Metadata is useful for storing additional, unstructured information on an object.\n    #[schema(value_type = Option<Object>, example = r#\"{ \"udf1\": \"some-value\", \"udf2\": \"some-value\" }\"#)]\n    pub metadata: Option<pii::SecretSerdeValue>,\n\n    /// Some connectors like Apple pay, Airwallex and Noon might require some additional information, find specific details in the child attributes below.\n    #[schema(value_type = Option<ConnectorMetadata>)]\n    pub connector_metadata: Option<pii::SecretSerdeValue>,\n\n    /// Additional data that might be required by hyperswitch based on the requested features by the merchants.\n    #[schema(value_type = Option<FeatureMetadata>)]\n    pub feature_metadata: Option<FeatureMetadata>,\n\n    /// Whether to generate the payment link for this payment or not (if applicable)\n    #[schema(value_type = EnablePaymentLinkRequest)]\n    pub payment_link_enabled: common_enums::EnablePaymentLinkRequest,\n\n    /// Configure a custom payment link for the particular payment\n    #[schema(value_type = Option<PaymentLinkConfigRequest>)]\n    pub payment_link_config: Option<admin::PaymentLinkConfigRequest>,\n\n    ///Request an incremental authorization, i.e., increase the authorized amount on a confirmed payment before you capture it.\n    #[schema(value_type = RequestIncrementalAuthorization)]\n    pub request_incremental_authorization: common_enums::RequestIncrementalAuthorization,\n\n    ///Will be used to expire client secret after certain amount of time to be supplied in seconds\n    #[serde(with = \"common_utils::custom_serde::iso8601\")]\n    pub expires_on: PrimitiveDateTime,\n\n    /// Additional data related to some frm(Fraud Risk Management) connectors\n    #[schema(value_type = Option<Object>, example = r#\"{ \"coverage_request\" : \"fraud\", \"fulfillment_method\" : \"delivery\" }\"#)]\n    pub frm_metadata: Option<pii::SecretSerdeValue>,\n\n    /// Whether to perform external authentication (if applicable)\n    #[schema(value_type = External3dsAuthenticationRequest)]\n    pub request_external_three_ds_authentication: common_enums::External3dsAuthenticationRequest,\n}",
+      "diff_span": {
+        "before": "\n    /// The identifier for the customer\n    #[schema(value_type = Option<String>, max_length = 64, min_length = 1, example = \"cus_y3oqhf46pyzuxjbcn2giaqnb44\")]\n    pub customer_id: Option<id_type::GlobalCustomerId>,\n",
+        "after": "\n    /// The identifier for the customer\n    #[schema(\n        min_length = 32,\n        max_length = 64,\n        example = \"12345_cus_01926c58bc6e77c09e809964e72af8c8\",\n        value_type = String\n    )]\n    pub customer_id: Option<id_type::GlobalCustomerId>,\n"
+      },
+      "commit_sha": "b3a029767505b8dff53e38844bb5c1c559570f43"
+    },
+    {
+      "id": "crates/api_models/src/payment_methods.rs::struct::PaymentMethodCreate",
+      "file": "crates/api_models/src/payment_methods.rs",
+      "kind": "struct_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub struct PaymentMethodCreate {\n    /// The type of payment method use for the payment.\n    #[schema(value_type = PaymentMethod,example = \"card\")]\n    pub payment_method_type: api_enums::PaymentMethod,\n\n    /// This is a sub-category of payment method.\n    #[schema(value_type = PaymentMethodType,example = \"credit\")]\n    pub payment_method_subtype: api_enums::PaymentMethodType,\n\n    /// You can specify up to 50 keys, with key names up to 40 characters long and values up to 500 characters long. Metadata is useful for storing additional, structured information on an object.\n    #[schema(value_type = Option<Object>,example = json!({ \"city\": \"NY\", \"unit\": \"245\" }))]\n    pub metadata: Option<pii::SecretSerdeValue>,\n\n    /// The unique identifier of the customer.\n    #[schema(value_type = String, max_length = 64, min_length = 1, example = \"cus_y3oqhf46pyzuxjbcn2giaqnb44\")]\n    pub customer_id: id_type::GlobalCustomerId,\n\n    /// Payment method data to be passed\n    pub payment_method_data: PaymentMethodCreateData,\n\n    /// The billing details of the payment method\n    #[schema(value_type = Option<Address>)]\n    pub billing: Option<payments::Address>,\n}",
+      "after_code": "pub struct PaymentMethodCreate {\n    /// The type of payment method use for the payment.\n    #[schema(value_type = PaymentMethod,example = \"card\")]\n    pub payment_method_type: api_enums::PaymentMethod,\n\n    /// This is a sub-category of payment method.\n    #[schema(value_type = PaymentMethodType,example = \"credit\")]\n    pub payment_method_subtype: api_enums::PaymentMethodType,\n\n    /// You can specify up to 50 keys, with key names up to 40 characters long and values up to 500 characters long. Metadata is useful for storing additional, structured information on an object.\n    #[schema(value_type = Option<Object>,example = json!({ \"city\": \"NY\", \"unit\": \"245\" }))]\n    pub metadata: Option<pii::SecretSerdeValue>,\n\n    /// The unique identifier of the customer.\n    #[schema(\n        min_length = 32,\n        max_length = 64,\n        example = \"12345_cus_01926c58bc6e77c09e809964e72af8c8\",\n        value_type = String\n    )]\n    pub customer_id: id_type::GlobalCustomerId,\n\n    /// Payment method data to be passed\n    pub payment_method_data: PaymentMethodCreateData,\n\n    /// The billing details of the payment method\n    #[schema(value_type = Option<Address>)]\n    pub billing: Option<payments::Address>,\n}",
+      "diff_span": {
+        "before": "\n    /// The unique identifier of the customer.\n    #[schema(value_type = String, max_length = 64, min_length = 1, example = \"cus_y3oqhf46pyzuxjbcn2giaqnb44\")]\n    pub customer_id: id_type::GlobalCustomerId,\n",
+        "after": "\n    /// The unique identifier of the customer.\n    #[schema(\n        min_length = 32,\n        max_length = 64,\n        example = \"12345_cus_01926c58bc6e77c09e809964e72af8c8\",\n        value_type = String\n    )]\n    pub customer_id: id_type::GlobalCustomerId,\n"
+      },
+      "commit_sha": "b3a029767505b8dff53e38844bb5c1c559570f43"
+    },
+    {
+      "id": "crates/api_models/src/payment_methods.rs::struct::PaymentMethodIntentCreate",
+      "file": "crates/api_models/src/payment_methods.rs",
+      "kind": "struct_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub struct PaymentMethodIntentCreate {\n    /// You can specify up to 50 keys, with key names up to 40 characters long and values up to 500 characters long. Metadata is useful for storing additional, structured information on an object.\n    #[schema(value_type = Option<Object>,example = json!({ \"city\": \"NY\", \"unit\": \"245\" }))]\n    pub metadata: Option<pii::SecretSerdeValue>,\n\n    /// The billing details of the payment method\n    #[schema(value_type = Option<Address>)]\n    pub billing: Option<payments::Address>,\n\n    /// The unique identifier of the customer.\n    #[schema(value_type = String, max_length = 64, min_length = 1, example = \"cus_y3oqhf46pyzuxjbcn2giaqnb44\")]\n    pub customer_id: id_type::GlobalCustomerId,\n}",
+      "after_code": "pub struct PaymentMethodIntentCreate {\n    /// You can specify up to 50 keys, with key names up to 40 characters long and values up to 500 characters long. Metadata is useful for storing additional, structured information on an object.\n    #[schema(value_type = Option<Object>,example = json!({ \"city\": \"NY\", \"unit\": \"245\" }))]\n    pub metadata: Option<pii::SecretSerdeValue>,\n\n    /// The billing details of the payment method\n    #[schema(value_type = Option<Address>)]\n    pub billing: Option<payments::Address>,\n\n    /// The unique identifier of the customer.\n    #[schema(\n        min_length = 32,\n        max_length = 64,\n        example = \"12345_cus_01926c58bc6e77c09e809964e72af8c8\",\n        value_type = String\n    )]\n    pub customer_id: id_type::GlobalCustomerId,\n}",
+      "diff_span": {
+        "before": "\n    /// The unique identifier of the customer.\n    #[schema(value_type = String, max_length = 64, min_length = 1, example = \"cus_y3oqhf46pyzuxjbcn2giaqnb44\")]\n    pub customer_id: id_type::GlobalCustomerId,\n}",
+        "after": "\n    /// The unique identifier of the customer.\n    #[schema(\n        min_length = 32,\n        max_length = 64,\n        example = \"12345_cus_01926c58bc6e77c09e809964e72af8c8\",\n        value_type = String\n    )]\n    pub customer_id: id_type::GlobalCustomerId,\n}"
+      },
+      "commit_sha": "b3a029767505b8dff53e38844bb5c1c559570f43"
+    },
+    {
+      "id": "crates/api_models/src/payment_methods.rs::struct::PaymentMethodResponse",
+      "file": "crates/api_models/src/payment_methods.rs",
+      "kind": "struct_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub struct PaymentMethodResponse {\n    /// Unique identifier for a merchant\n    #[schema(value_type = String, example = \"merchant_1671528864\")]\n    pub merchant_id: id_type::MerchantId,\n\n    /// The unique identifier of the customer.\n    #[schema(value_type = Option<String>, max_length = 64, min_length = 1, example = \"cus_y3oqhf46pyzuxjbcn2giaqnb44\")]\n    pub customer_id: id_type::GlobalCustomerId,\n\n    /// The unique identifier of the Payment method\n    #[schema(example = \"card_rGK4Vi5iSW70MY7J2mIg\")]\n    pub payment_method_id: String,\n\n    /// The type of payment method use for the payment.\n    #[schema(value_type = PaymentMethod, example = \"card\")]\n    pub payment_method_type: Option<api_enums::PaymentMethod>,\n\n    /// This is a sub-category of payment method.\n    #[schema(value_type = Option<PaymentMethodType>, example = \"credit\")]\n    pub payment_method_subtype: Option<api_enums::PaymentMethodType>,\n\n    /// Indicates whether the payment method is eligible for recurring payments\n    #[schema(example = true)]\n    pub recurring_enabled: bool,\n\n    /// A timestamp (ISO 8601 code) that determines when the payment method was created\n    #[schema(value_type = Option<PrimitiveDateTime>, example = \"2023-01-18T11:04:09.922Z\")]\n    #[serde(default, with = \"common_utils::custom_serde::iso8601::option\")]\n    pub created: Option<time::PrimitiveDateTime>,\n\n    #[schema(value_type = Option<PrimitiveDateTime>, example = \"2024-02-24T11:04:09.922Z\")]\n    #[serde(default, with = \"common_utils::custom_serde::iso8601::option\")]\n    pub last_used_at: Option<time::PrimitiveDateTime>,\n\n    /// For Client based calls\n    pub client_secret: Option<String>,\n\n    pub payment_method_data: Option<PaymentMethodResponseData>,\n}",
+      "after_code": "pub struct PaymentMethodResponse {\n    /// Unique identifier for a merchant\n    #[schema(value_type = String, example = \"merchant_1671528864\")]\n    pub merchant_id: id_type::MerchantId,\n\n    /// The unique identifier of the customer.\n    #[schema(\n        min_length = 32,\n        max_length = 64,\n        example = \"12345_cus_01926c58bc6e77c09e809964e72af8c8\",\n        value_type = String\n    )]\n    pub customer_id: id_type::GlobalCustomerId,\n\n    /// The unique identifier of the Payment method\n    #[schema(example = \"card_rGK4Vi5iSW70MY7J2mIg\")]\n    pub payment_method_id: String,\n\n    /// The type of payment method use for the payment.\n    #[schema(value_type = PaymentMethod, example = \"card\")]\n    pub payment_method_type: Option<api_enums::PaymentMethod>,\n\n    /// This is a sub-category of payment method.\n    #[schema(value_type = Option<PaymentMethodType>, example = \"credit\")]\n    pub payment_method_subtype: Option<api_enums::PaymentMethodType>,\n\n    /// Indicates whether the payment method is eligible for recurring payments\n    #[schema(example = true)]\n    pub recurring_enabled: bool,\n\n    /// A timestamp (ISO 8601 code) that determines when the payment method was created\n    #[schema(value_type = Option<PrimitiveDateTime>, example = \"2023-01-18T11:04:09.922Z\")]\n    #[serde(default, with = \"common_utils::custom_serde::iso8601::option\")]\n    pub created: Option<time::PrimitiveDateTime>,\n\n    #[schema(value_type = Option<PrimitiveDateTime>, example = \"2024-02-24T11:04:09.922Z\")]\n    #[serde(default, with = \"common_utils::custom_serde::iso8601::option\")]\n    pub last_used_at: Option<time::PrimitiveDateTime>,\n\n    /// For Client based calls\n    pub client_secret: Option<String>,\n\n    pub payment_method_data: Option<PaymentMethodResponseData>,\n}",
+      "diff_span": {
+        "before": "\n    /// The unique identifier of the customer.\n    #[schema(value_type = Option<String>, max_length = 64, min_length = 1, example = \"cus_y3oqhf46pyzuxjbcn2giaqnb44\")]\n    pub customer_id: id_type::GlobalCustomerId,\n",
+        "after": "\n    /// The unique identifier of the customer.\n    #[schema(\n        min_length = 32,\n        max_length = 64,\n        example = \"12345_cus_01926c58bc6e77c09e809964e72af8c8\",\n        value_type = String\n    )]\n    pub customer_id: id_type::GlobalCustomerId,\n"
+      },
+      "commit_sha": "b3a029767505b8dff53e38844bb5c1c559570f43"
+    },
+    {
+      "id": "crates/api_models/src/payments.rs::struct::PaymentsCreateIntentRequest",
+      "file": "crates/api_models/src/payments.rs",
+      "kind": "struct_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub struct PaymentsCreateIntentRequest {\n    /// The amount details for the payment\n    pub amount_details: AmountDetails,\n\n    /// Unique identifier for the payment. This ensures idempotency for multiple payments\n    /// that have been done by a single merchant.\n    #[schema(\n        value_type = Option<String>,\n        min_length = 30,\n        max_length = 30,\n        example = \"pay_mbabizu24mvu3mela5njyhpit4\"\n    )]\n    pub merchant_reference_id: Option<id_type::PaymentReferenceId>,\n\n    /// The routing algorithm id to be used for the payment\n    #[schema(value_type = Option<String>)]\n    pub routing_algorithm_id: Option<id_type::RoutingId>,\n\n    #[schema(value_type = Option<CaptureMethod>, example = \"automatic\")]\n    pub capture_method: Option<api_enums::CaptureMethod>,\n\n    #[schema(value_type = Option<AuthenticationType>, example = \"no_three_ds\", default = \"no_three_ds\")]\n    pub authentication_type: Option<api_enums::AuthenticationType>,\n\n    /// The billing details of the payment. This address will be used for invoicing.\n    pub billing: Option<Address>,\n\n    /// The shipping address for the payment\n    pub shipping: Option<Address>,\n\n    /// The identifier for the customer\n    #[schema(value_type = Option<String>, max_length = 64, min_length = 1, example = \"cus_y3oqhf46pyzuxjbcn2giaqnb44\")]\n    pub customer_id: Option<id_type::GlobalCustomerId>,\n\n    /// Set to `present` to indicate that the customer is in your checkout flow during this payment, and therefore is able to authenticate. This parameter should be `absent` when merchant's doing merchant initiated payments and customer is not present while doing the payment.\n    #[schema(example = \"present\", value_type = Option<PresenceOfCustomerDuringPayment>)]\n    pub customer_present: Option<common_enums::PresenceOfCustomerDuringPayment>,\n\n    /// A description for the payment\n    #[schema(example = \"It's my first payment request\", value_type = Option<String>)]\n    pub description: Option<common_utils::types::Description>,\n\n    /// The URL to which you want the user to be redirected after the completion of the payment operation\n    #[schema(value_type = Option<String>, example = \"https://hyperswitch.io\")]\n    pub return_url: Option<common_utils::types::Url>,\n\n    #[schema(value_type = Option<FutureUsage>, example = \"off_session\")]\n    pub setup_future_usage: Option<api_enums::FutureUsage>,\n\n    /// Apply MIT exemption for a payment\n    #[schema(value_type = Option<MitExemptionRequest>)]\n    pub apply_mit_exemption: Option<common_enums::MitExemptionRequest>,\n\n    /// For non-card charges, you can use this value as the complete description that appears on your customers\u2019 statements. Must contain at least one letter, maximum 22 characters.\n    #[schema(max_length = 22, example = \"Hyperswitch Router\", value_type = Option<String>)]\n    pub statement_descriptor: Option<common_utils::types::StatementDescriptor>,\n\n    /// Use this object to capture the details about the different products for which the payment is being made. The sum of amount across different products here should be equal to the overall payment amount\n    #[schema(value_type = Option<Vec<OrderDetailsWithAmount>>, example = r#\"[{\n        \"product_name\": \"Apple iPhone 16\",\n        \"quantity\": 1,\n        \"amount\" : 69000\n        \"product_img_link\" : \"https://dummy-img-link.com\"\n    }]\"#)]\n    pub order_details: Option<Vec<OrderDetailsWithAmount>>,\n\n    /// Use this parameter to restrict the Payment Method Types to show for a given PaymentIntent\n    #[schema(value_type = Option<Vec<PaymentMethodType>>)]\n    pub allowed_payment_method_types: Option<Vec<api_enums::PaymentMethodType>>,\n\n    /// Metadata is useful for storing additional, unstructured information on an object.\n    #[schema(value_type = Option<Object>, example = r#\"{ \"udf1\": \"some-value\", \"udf2\": \"some-value\" }\"#)]\n    pub metadata: Option<pii::SecretSerdeValue>,\n\n    /// Some connectors like Apple pay, Airwallex and Noon might require some additional information, find specific details in the child attributes below.\n    pub connector_metadata: Option<ConnectorMetadata>,\n\n    /// Additional data that might be required by hyperswitch based on the requested features by the merchants.\n    pub feature_metadata: Option<FeatureMetadata>,\n\n    /// Whether to generate the payment link for this payment or not (if applicable)\n    #[schema(value_type = Option<EnablePaymentLinkRequest>)]\n    pub payment_link_enabled: Option<common_enums::EnablePaymentLinkRequest>,\n\n    /// Configure a custom payment link for the particular payment\n    #[schema(value_type = Option<PaymentLinkConfigRequest>)]\n    pub payment_link_config: Option<admin::PaymentLinkConfigRequest>,\n\n    ///Request an incremental authorization, i.e., increase the authorized amount on a confirmed payment before you capture it.\n    #[schema(value_type = Option<RequestIncrementalAuthorization>)]\n    pub request_incremental_authorization: Option<common_enums::RequestIncrementalAuthorization>,\n\n    ///Will be used to expire client secret after certain amount of time to be supplied in seconds, if not sent it will be taken from profile config\n    ///(900) for 15 mins\n    #[schema(example = 900)]\n    pub session_expiry: Option<u32>,\n\n    /// Additional data related to some frm(Fraud Risk Management) connectors\n    #[schema(value_type = Option<Object>, example = r#\"{ \"coverage_request\" : \"fraud\", \"fulfillment_method\" : \"delivery\" }\"#)]\n    pub frm_metadata: Option<pii::SecretSerdeValue>,\n\n    /// Whether to perform external authentication (if applicable)\n    #[schema(value_type = Option<External3dsAuthenticationRequest>)]\n    pub request_external_three_ds_authentication:\n        Option<common_enums::External3dsAuthenticationRequest>,\n}",
+      "after_code": "pub struct PaymentsCreateIntentRequest {\n    /// The amount details for the payment\n    pub amount_details: AmountDetails,\n\n    /// Unique identifier for the payment. This ensures idempotency for multiple payments\n    /// that have been done by a single merchant.\n    #[schema(\n        value_type = Option<String>,\n        min_length = 30,\n        max_length = 30,\n        example = \"pay_mbabizu24mvu3mela5njyhpit4\"\n    )]\n    pub merchant_reference_id: Option<id_type::PaymentReferenceId>,\n\n    /// The routing algorithm id to be used for the payment\n    #[schema(value_type = Option<String>)]\n    pub routing_algorithm_id: Option<id_type::RoutingId>,\n\n    #[schema(value_type = Option<CaptureMethod>, example = \"automatic\")]\n    pub capture_method: Option<api_enums::CaptureMethod>,\n\n    #[schema(value_type = Option<AuthenticationType>, example = \"no_three_ds\", default = \"no_three_ds\")]\n    pub authentication_type: Option<api_enums::AuthenticationType>,\n\n    /// The billing details of the payment. This address will be used for invoicing.\n    pub billing: Option<Address>,\n\n    /// The shipping address for the payment\n    pub shipping: Option<Address>,\n\n    /// The identifier for the customer\n    #[schema(\n        min_length = 32,\n        max_length = 64,\n        example = \"12345_cus_01926c58bc6e77c09e809964e72af8c8\",\n        value_type = String\n    )]\n    pub customer_id: Option<id_type::GlobalCustomerId>,\n\n    /// Set to `present` to indicate that the customer is in your checkout flow during this payment, and therefore is able to authenticate. This parameter should be `absent` when merchant's doing merchant initiated payments and customer is not present while doing the payment.\n    #[schema(example = \"present\", value_type = Option<PresenceOfCustomerDuringPayment>)]\n    pub customer_present: Option<common_enums::PresenceOfCustomerDuringPayment>,\n\n    /// A description for the payment\n    #[schema(example = \"It's my first payment request\", value_type = Option<String>)]\n    pub description: Option<common_utils::types::Description>,\n\n    /// The URL to which you want the user to be redirected after the completion of the payment operation\n    #[schema(value_type = Option<String>, example = \"https://hyperswitch.io\")]\n    pub return_url: Option<common_utils::types::Url>,\n\n    #[schema(value_type = Option<FutureUsage>, example = \"off_session\")]\n    pub setup_future_usage: Option<api_enums::FutureUsage>,\n\n    /// Apply MIT exemption for a payment\n    #[schema(value_type = Option<MitExemptionRequest>)]\n    pub apply_mit_exemption: Option<common_enums::MitExemptionRequest>,\n\n    /// For non-card charges, you can use this value as the complete description that appears on your customers\u2019 statements. Must contain at least one letter, maximum 22 characters.\n    #[schema(max_length = 22, example = \"Hyperswitch Router\", value_type = Option<String>)]\n    pub statement_descriptor: Option<common_utils::types::StatementDescriptor>,\n\n    /// Use this object to capture the details about the different products for which the payment is being made. The sum of amount across different products here should be equal to the overall payment amount\n    #[schema(value_type = Option<Vec<OrderDetailsWithAmount>>, example = r#\"[{\n        \"product_name\": \"Apple iPhone 16\",\n        \"quantity\": 1,\n        \"amount\" : 69000\n        \"product_img_link\" : \"https://dummy-img-link.com\"\n    }]\"#)]\n    pub order_details: Option<Vec<OrderDetailsWithAmount>>,\n\n    /// Use this parameter to restrict the Payment Method Types to show for a given PaymentIntent\n    #[schema(value_type = Option<Vec<PaymentMethodType>>)]\n    pub allowed_payment_method_types: Option<Vec<api_enums::PaymentMethodType>>,\n\n    /// Metadata is useful for storing additional, unstructured information on an object.\n    #[schema(value_type = Option<Object>, example = r#\"{ \"udf1\": \"some-value\", \"udf2\": \"some-value\" }\"#)]\n    pub metadata: Option<pii::SecretSerdeValue>,\n\n    /// Some connectors like Apple pay, Airwallex and Noon might require some additional information, find specific details in the child attributes below.\n    pub connector_metadata: Option<ConnectorMetadata>,\n\n    /// Additional data that might be required by hyperswitch based on the requested features by the merchants.\n    pub feature_metadata: Option<FeatureMetadata>,\n\n    /// Whether to generate the payment link for this payment or not (if applicable)\n    #[schema(value_type = Option<EnablePaymentLinkRequest>)]\n    pub payment_link_enabled: Option<common_enums::EnablePaymentLinkRequest>,\n\n    /// Configure a custom payment link for the particular payment\n    #[schema(value_type = Option<PaymentLinkConfigRequest>)]\n    pub payment_link_config: Option<admin::PaymentLinkConfigRequest>,\n\n    ///Request an incremental authorization, i.e., increase the authorized amount on a confirmed payment before you capture it.\n    #[schema(value_type = Option<RequestIncrementalAuthorization>)]\n    pub request_incremental_authorization: Option<common_enums::RequestIncrementalAuthorization>,\n\n    ///Will be used to expire client secret after certain amount of time to be supplied in seconds, if not sent it will be taken from profile config\n    ///(900) for 15 mins\n    #[schema(example = 900)]\n    pub session_expiry: Option<u32>,\n\n    /// Additional data related to some frm(Fraud Risk Management) connectors\n    #[schema(value_type = Option<Object>, example = r#\"{ \"coverage_request\" : \"fraud\", \"fulfillment_method\" : \"delivery\" }\"#)]\n    pub frm_metadata: Option<pii::SecretSerdeValue>,\n\n    /// Whether to perform external authentication (if applicable)\n    #[schema(value_type = Option<External3dsAuthenticationRequest>)]\n    pub request_external_three_ds_authentication:\n        Option<common_enums::External3dsAuthenticationRequest>,\n}",
+      "diff_span": {
+        "before": "\n    /// The identifier for the customer\n    #[schema(value_type = Option<String>, max_length = 64, min_length = 1, example = \"cus_y3oqhf46pyzuxjbcn2giaqnb44\")]\n    pub customer_id: Option<id_type::GlobalCustomerId>,\n",
+        "after": "\n    /// The identifier for the customer\n    #[schema(\n        min_length = 32,\n        max_length = 64,\n        example = \"12345_cus_01926c58bc6e77c09e809964e72af8c8\",\n        value_type = String\n    )]\n    pub customer_id: Option<id_type::GlobalCustomerId>,\n"
+      },
+      "commit_sha": "b3a029767505b8dff53e38844bb5c1c559570f43"
+    }
+  ]
+}

diffs/pr_6836/bcade37/diff.json

@@ -0,0 +1,55 @@
+{
+  "commit_sha": "bcade3783fb617fac2b1819ced467cf0ef39a053",
+  "pr_number": 6836,
+  "rust_files": [
+    "crates/api_models/src/ephemeral_key.rs",
+    "crates/router/src/routes/ephemeral_key.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/router/src/routes/ephemeral_key.rs::function::ephemeral_key_create",
+      "file": "crates/router/src/routes/ephemeral_key.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn ephemeral_key_create(\n    state: web::Data<AppState>,\n    req: HttpRequest,\n    json_payload: web::Json<common_utils::id_type::CustomerId>,\n) -> HttpResponse {\n    let flow = Flow::EphemeralKeyCreate;\n    let customer_id = json_payload.into_inner();\n    api::server_wrap(\n        flow,\n        state,\n        &req,\n        customer_id,\n        |state, auth: auth::AuthenticationData, customer_id, _| {\n            helpers::make_ephemeral_key(\n                state,\n                customer_id,\n                auth.merchant_account.get_id().to_owned(),\n            )\n        },\n        &auth::HeaderAuth(auth::ApiKeyAuth),\n        api_locking::LockAction::NotApplicable,\n    )\n    .await\n}",
+      "after_code": "pub async fn ephemeral_key_create(\n    state: web::Data<AppState>,\n    req: HttpRequest,\n    json_payload: web::Json<api_models::ephemeral_key::EphemeralKeyCreateRequest>,\n) -> HttpResponse {\n    let flow = Flow::EphemeralKeyCreate;\n    let payload = json_payload.into_inner();\n    api::server_wrap(\n        flow,\n        state,\n        &req,\n        payload,\n        |state, auth: auth::AuthenticationData, payload, _| {\n            helpers::make_ephemeral_key(\n                state,\n                payload.customer_id,\n                auth.merchant_account.get_id().to_owned(),\n            )\n        },\n        &auth::HeaderAuth(auth::ApiKeyAuth),\n        api_locking::LockAction::NotApplicable,\n    )\n    .await\n}",
+      "diff_span": {
+        "before": "    state: web::Data<AppState>,\n    req: HttpRequest,\n    json_payload: web::Json<common_utils::id_type::CustomerId>,\n) -> HttpResponse {\n    let flow = Flow::EphemeralKeyCreate;\n    let customer_id = json_payload.into_inner();\n    api::server_wrap(\n        flow,\n        state,\n        &req,\n        customer_id,\n        |state, auth: auth::AuthenticationData, customer_id, _| {\n            helpers::make_ephemeral_key(\n                state,\n                customer_id,\n                auth.merchant_account.get_id().to_owned(),\n            )",
+        "after": "    state: web::Data<AppState>,\n    req: HttpRequest,\n    json_payload: web::Json<api_models::ephemeral_key::EphemeralKeyCreateRequest>,\n) -> HttpResponse {\n    let flow = Flow::EphemeralKeyCreate;\n    let payload = json_payload.into_inner();\n    api::server_wrap(\n        flow,\n        state,\n        &req,\n        payload,\n        |state, auth: auth::AuthenticationData, payload, _| {\n            helpers::make_ephemeral_key(\n                state,\n                payload.customer_id,\n                auth.merchant_account.get_id().to_owned(),\n            )"
+      },
+      "commit_sha": "bcade3783fb617fac2b1819ced467cf0ef39a053"
+    },
+    {
+      "id": "crates/api_models/src/ephemeral_key.rs::EphemeralKeyCreateRequest::function::get_api_event_type",
+      "file": "crates/api_models/src/ephemeral_key.rs",
+      "kind": "function_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "fn get_api_event_type(&self) -> Option<common_utils::events::ApiEventsType> {\n        Some(common_utils::events::ApiEventsType::Miscellaneous)\n    }",
+      "diff_span": null,
+      "commit_sha": "bcade3783fb617fac2b1819ced467cf0ef39a053"
+    },
+    {
+      "id": "crates/api_models/src/ephemeral_key.rs::impl::EphemeralKeyCreateRequest",
+      "file": "crates/api_models/src/ephemeral_key.rs",
+      "kind": "impl_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "impl common_utils::events::ApiEventMetric for EphemeralKeyCreateRequest {\n    fn get_api_event_type(&self) -> Option<common_utils::events::ApiEventsType> {\n        Some(common_utils::events::ApiEventsType::Miscellaneous)\n    }\n}",
+      "diff_span": null,
+      "commit_sha": "bcade3783fb617fac2b1819ced467cf0ef39a053"
+    },
+    {
+      "id": "crates/api_models/src/ephemeral_key.rs::struct::EphemeralKeyCreateRequest",
+      "file": "crates/api_models/src/ephemeral_key.rs",
+      "kind": "struct_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "pub struct EphemeralKeyCreateRequest {\n    /// Customer ID for which an ephemeral key must be created\n    #[schema(\n        min_length = 1,\n        max_length = 64,\n        value_type = String,\n        example = \"cus_y3oqhf46pyzuxjbcn2giaqnb44\"\n    )]\n    pub customer_id: id_type::CustomerId,\n}",
+      "diff_span": null,
+      "commit_sha": "bcade3783fb617fac2b1819ced467cf0ef39a053"
+    }
+  ]
+}

diffs/pr_6836/c12d8ef/diff.json

@@ -0,0 +1,6 @@
+{
+  "commit_sha": "c12d8eff454736b9e2d49e9f4cab64bf790ec6a3",
+  "pr_number": 6836,
+  "rust_files": [],
+  "diffs": []
+}

diffs/pr_6859/0e7922b/diff.json

@@ -0,0 +1,6 @@
+{
+  "commit_sha": "0e7922b5cf45f2c688ac42b2afd0cedd84b8232b",
+  "pr_number": 6859,
+  "rust_files": [],
+  "diffs": []
+}

diffs/pr_6859/249e82b/diff.json

@@ -0,0 +1,6 @@
+{
+  "commit_sha": "249e82b7c0dd72390259277a0c2cbd12b74a2663",
+  "pr_number": 6859,
+  "rust_files": [],
+  "diffs": []
+}

diffs/pr_6859/2e791d5/diff.json

@@ -0,0 +1,150 @@
+{
+  "commit_sha": "2e791d5289a5eaf011722af0413bc64967acca19",
+  "pr_number": 6859,
+  "rust_files": [
+    "crates/common_types/src/payments.rs",
+    "crates/router/src/core/payments.rs",
+    "crates/router/src/core/payments/helpers.rs",
+    "crates/router/src/core/payments/operations.rs",
+    "crates/router/src/core/payments/operations/payment_confirm.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/router/src/core/payments/operations.rs::Domain::function::call_unified_authentication_service_if_eligible",
+      "file": "crates/router/src/core/payments/operations.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "async fn call_unified_authentication_service_if_eligible<'a>(\n        &'a self,\n        _state: &SessionState,\n        _payment_data: &mut D,\n        _should_continue_confirm_transaction: &mut bool,\n        _connector_call_type: &ConnectorCallType,\n        _merchant_account: &domain::Profile,\n        _key_store: &domain::MerchantKeyStore,\n        _authentication_product_ids: &common_types::payments::AuthenticationConnectorAccountMap,\n    ) -> CustomResult<(), errors::ApiErrorResponse> {\n        Ok(())\n    }",
+      "after_code": "async fn call_unified_authentication_service_if_eligible<'a>(\n        &'a self,\n        _state: &SessionState,\n        _payment_data: &mut D,\n        _should_continue_confirm_transaction: &mut bool,\n        _connector_call_type: &ConnectorCallType,\n        _merchant_account: &domain::Profile,\n        _key_store: &domain::MerchantKeyStore,\n    ) -> CustomResult<(), errors::ApiErrorResponse> {\n        Ok(())\n    }",
+      "diff_span": {
+        "before": "        _merchant_account: &domain::Profile,\n        _key_store: &domain::MerchantKeyStore,\n        _authentication_product_ids: &common_types::payments::AuthenticationConnectorAccountMap,\n    ) -> CustomResult<(), errors::ApiErrorResponse> {\n        Ok(())",
+        "after": ""
+      },
+      "commit_sha": "2e791d5289a5eaf011722af0413bc64967acca19"
+    },
+    {
+      "id": "crates/router/src/core/payments/operations.rs::trait::Domain",
+      "file": "crates/router/src/core/payments/operations.rs",
+      "kind": "trait_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub trait Domain<F: Clone, R, D>: Send + Sync {\n    #[cfg(feature = \"v1\")]\n    /// This will fetch customer details, (this operation is flow specific)\n    async fn get_or_create_customer_details<'a>(\n        &'a self,\n        state: &SessionState,\n        payment_data: &mut D,\n        request: Option<CustomerDetails>,\n        merchant_key_store: &domain::MerchantKeyStore,\n        storage_scheme: enums::MerchantStorageScheme,\n    ) -> CustomResult<(BoxedOperation<'a, F, R, D>, Option<domain::Customer>), errors::StorageError>;\n\n    #[cfg(feature = \"v2\")]\n    /// This will fetch customer details, (this operation is flow specific)\n    async fn get_customer_details<'a>(\n        &'a self,\n        state: &SessionState,\n        payment_data: &mut D,\n        merchant_key_store: &domain::MerchantKeyStore,\n        storage_scheme: enums::MerchantStorageScheme,\n    ) -> CustomResult<(BoxedOperation<'a, F, R, D>, Option<domain::Customer>), errors::StorageError>;\n\n    #[allow(clippy::too_many_arguments)]\n    async fn make_pm_data<'a>(\n        &'a self,\n        state: &'a SessionState,\n        payment_data: &mut D,\n        storage_scheme: enums::MerchantStorageScheme,\n        merchant_key_store: &domain::MerchantKeyStore,\n        customer: &Option<domain::Customer>,\n        business_profile: &domain::Profile,\n    ) -> RouterResult<(\n        BoxedOperation<'a, F, R, D>,\n        Option<domain::PaymentMethodData>,\n        Option<String>,\n    )>;\n\n    async fn add_task_to_process_tracker<'a>(\n        &'a self,\n        _db: &'a SessionState,\n        _payment_attempt: &storage::PaymentAttempt,\n        _requeue: bool,\n        _schedule_time: Option<time::PrimitiveDateTime>,\n    ) -> CustomResult<(), errors::ApiErrorResponse> {\n        Ok(())\n    }\n\n    #[cfg(feature = \"v1\")]\n    async fn get_connector<'a>(\n        &'a self,\n        merchant_account: &domain::MerchantAccount,\n        state: &SessionState,\n        request: &R,\n        payment_intent: &storage::PaymentIntent,\n        mechant_key_store: &domain::MerchantKeyStore,\n    ) -> CustomResult<api::ConnectorChoice, errors::ApiErrorResponse>;\n\n    #[cfg(feature = \"v2\")]\n    async fn perform_routing<'a>(\n        &'a self,\n        merchant_account: &domain::MerchantAccount,\n        business_profile: &domain::Profile,\n        state: &SessionState,\n        // TODO: do not take the whole payment data here\n        payment_data: &mut D,\n        mechant_key_store: &domain::MerchantKeyStore,\n    ) -> CustomResult<ConnectorCallType, errors::ApiErrorResponse>;\n\n    async fn populate_payment_data<'a>(\n        &'a self,\n        _state: &SessionState,\n        _payment_data: &mut D,\n        _merchant_account: &domain::MerchantAccount,\n    ) -> CustomResult<(), errors::ApiErrorResponse> {\n        Ok(())\n    }\n\n    #[allow(clippy::too_many_arguments)]\n    async fn call_external_three_ds_authentication_if_eligible<'a>(\n        &'a self,\n        _state: &SessionState,\n        _payment_data: &mut D,\n        _should_continue_confirm_transaction: &mut bool,\n        _connector_call_type: &ConnectorCallType,\n        _merchant_account: &domain::Profile,\n        _key_store: &domain::MerchantKeyStore,\n        _mandate_type: Option<api_models::payments::MandateTransactionType>,\n    ) -> CustomResult<(), errors::ApiErrorResponse> {\n        Ok(())\n    }\n\n    #[allow(clippy::too_many_arguments)]\n    async fn call_unified_authentication_service_if_eligible<'a>(\n        &'a self,\n        _state: &SessionState,\n        _payment_data: &mut D,\n        _should_continue_confirm_transaction: &mut bool,\n        _connector_call_type: &ConnectorCallType,\n        _merchant_account: &domain::Profile,\n        _key_store: &domain::MerchantKeyStore,\n        _authentication_product_ids: &common_types::payments::AuthenticationConnectorAccountMap,\n    ) -> CustomResult<(), errors::ApiErrorResponse> {\n        Ok(())\n    }\n\n    #[allow(clippy::too_many_arguments)]\n    async fn payments_dynamic_tax_calculation<'a>(\n        &'a self,\n        _state: &SessionState,\n        _payment_data: &mut D,\n        _connector_call_type: &ConnectorCallType,\n        _business_profile: &domain::Profile,\n        _key_store: &domain::MerchantKeyStore,\n        _merchant_account: &domain::MerchantAccount,\n    ) -> CustomResult<(), errors::ApiErrorResponse> {\n        Ok(())\n    }\n\n    #[instrument(skip_all)]\n    async fn guard_payment_against_blocklist<'a>(\n        &'a self,\n        _state: &SessionState,\n        _merchant_account: &domain::MerchantAccount,\n        _key_store: &domain::MerchantKeyStore,\n        _payment_data: &mut D,\n    ) -> CustomResult<bool, errors::ApiErrorResponse> {\n        Ok(false)\n    }\n\n    async fn store_extended_card_info_temporarily<'a>(\n        &'a self,\n        _state: &SessionState,\n        _payment_id: &common_utils::id_type::PaymentId,\n        _business_profile: &domain::Profile,\n        _payment_method_data: Option<&domain::PaymentMethodData>,\n    ) -> CustomResult<(), errors::ApiErrorResponse> {\n        Ok(())\n    }\n\n    // #[cfg(feature = \"v2\")]\n    // async fn call_connector<'a, RouterDataReq>(\n    //     &'a self,\n    //     _state: &SessionState,\n    //     _req_state: ReqState,\n    //     _merchant_account: &domain::MerchantAccount,\n    //     _key_store: &domain::MerchantKeyStore,\n    //     _business_profile: &domain::Profile,\n    //     _payment_method_data: Option<&domain::PaymentMethodData>,\n    //     _connector: api::ConnectorData,\n    //     _customer: &Option<domain::Customer>,\n    //     _payment_data: &mut D,\n    //     _call_connector_action: common_enums::CallConnectorAction,\n    // ) -> CustomResult<\n    //     hyperswitch_domain_models::router_data::RouterData<F, RouterDataReq, PaymentsResponseData>,\n    //     errors::ApiErrorResponse,\n    // > {\n    //     // TODO: raise an error here\n    //     todo!();\n    // }\n}",
+      "after_code": "pub trait Domain<F: Clone, R, D>: Send + Sync {\n    #[cfg(feature = \"v1\")]\n    /// This will fetch customer details, (this operation is flow specific)\n    async fn get_or_create_customer_details<'a>(\n        &'a self,\n        state: &SessionState,\n        payment_data: &mut D,\n        request: Option<CustomerDetails>,\n        merchant_key_store: &domain::MerchantKeyStore,\n        storage_scheme: enums::MerchantStorageScheme,\n    ) -> CustomResult<(BoxedOperation<'a, F, R, D>, Option<domain::Customer>), errors::StorageError>;\n\n    #[cfg(feature = \"v2\")]\n    /// This will fetch customer details, (this operation is flow specific)\n    async fn get_customer_details<'a>(\n        &'a self,\n        state: &SessionState,\n        payment_data: &mut D,\n        merchant_key_store: &domain::MerchantKeyStore,\n        storage_scheme: enums::MerchantStorageScheme,\n    ) -> CustomResult<(BoxedOperation<'a, F, R, D>, Option<domain::Customer>), errors::StorageError>;\n\n    #[allow(clippy::too_many_arguments)]\n    async fn make_pm_data<'a>(\n        &'a self,\n        state: &'a SessionState,\n        payment_data: &mut D,\n        storage_scheme: enums::MerchantStorageScheme,\n        merchant_key_store: &domain::MerchantKeyStore,\n        customer: &Option<domain::Customer>,\n        business_profile: &domain::Profile,\n    ) -> RouterResult<(\n        BoxedOperation<'a, F, R, D>,\n        Option<domain::PaymentMethodData>,\n        Option<String>,\n    )>;\n\n    async fn add_task_to_process_tracker<'a>(\n        &'a self,\n        _db: &'a SessionState,\n        _payment_attempt: &storage::PaymentAttempt,\n        _requeue: bool,\n        _schedule_time: Option<time::PrimitiveDateTime>,\n    ) -> CustomResult<(), errors::ApiErrorResponse> {\n        Ok(())\n    }\n\n    #[cfg(feature = \"v1\")]\n    async fn get_connector<'a>(\n        &'a self,\n        merchant_account: &domain::MerchantAccount,\n        state: &SessionState,\n        request: &R,\n        payment_intent: &storage::PaymentIntent,\n        mechant_key_store: &domain::MerchantKeyStore,\n    ) -> CustomResult<api::ConnectorChoice, errors::ApiErrorResponse>;\n\n    #[cfg(feature = \"v2\")]\n    async fn perform_routing<'a>(\n        &'a self,\n        merchant_account: &domain::MerchantAccount,\n        business_profile: &domain::Profile,\n        state: &SessionState,\n        // TODO: do not take the whole payment data here\n        payment_data: &mut D,\n        mechant_key_store: &domain::MerchantKeyStore,\n    ) -> CustomResult<ConnectorCallType, errors::ApiErrorResponse>;\n\n    async fn populate_payment_data<'a>(\n        &'a self,\n        _state: &SessionState,\n        _payment_data: &mut D,\n        _merchant_account: &domain::MerchantAccount,\n    ) -> CustomResult<(), errors::ApiErrorResponse> {\n        Ok(())\n    }\n\n    #[allow(clippy::too_many_arguments)]\n    async fn call_external_three_ds_authentication_if_eligible<'a>(\n        &'a self,\n        _state: &SessionState,\n        _payment_data: &mut D,\n        _should_continue_confirm_transaction: &mut bool,\n        _connector_call_type: &ConnectorCallType,\n        _merchant_account: &domain::Profile,\n        _key_store: &domain::MerchantKeyStore,\n        _mandate_type: Option<api_models::payments::MandateTransactionType>,\n    ) -> CustomResult<(), errors::ApiErrorResponse> {\n        Ok(())\n    }\n\n    #[allow(clippy::too_many_arguments)]\n    async fn call_unified_authentication_service_if_eligible<'a>(\n        &'a self,\n        _state: &SessionState,\n        _payment_data: &mut D,\n        _should_continue_confirm_transaction: &mut bool,\n        _connector_call_type: &ConnectorCallType,\n        _merchant_account: &domain::Profile,\n        _key_store: &domain::MerchantKeyStore,\n    ) -> CustomResult<(), errors::ApiErrorResponse> {\n        Ok(())\n    }\n\n    #[allow(clippy::too_many_arguments)]\n    async fn payments_dynamic_tax_calculation<'a>(\n        &'a self,\n        _state: &SessionState,\n        _payment_data: &mut D,\n        _connector_call_type: &ConnectorCallType,\n        _business_profile: &domain::Profile,\n        _key_store: &domain::MerchantKeyStore,\n        _merchant_account: &domain::MerchantAccount,\n    ) -> CustomResult<(), errors::ApiErrorResponse> {\n        Ok(())\n    }\n\n    #[instrument(skip_all)]\n    async fn guard_payment_against_blocklist<'a>(\n        &'a self,\n        _state: &SessionState,\n        _merchant_account: &domain::MerchantAccount,\n        _key_store: &domain::MerchantKeyStore,\n        _payment_data: &mut D,\n    ) -> CustomResult<bool, errors::ApiErrorResponse> {\n        Ok(false)\n    }\n\n    async fn store_extended_card_info_temporarily<'a>(\n        &'a self,\n        _state: &SessionState,\n        _payment_id: &common_utils::id_type::PaymentId,\n        _business_profile: &domain::Profile,\n        _payment_method_data: Option<&domain::PaymentMethodData>,\n    ) -> CustomResult<(), errors::ApiErrorResponse> {\n        Ok(())\n    }\n\n    // #[cfg(feature = \"v2\")]\n    // async fn call_connector<'a, RouterDataReq>(\n    //     &'a self,\n    //     _state: &SessionState,\n    //     _req_state: ReqState,\n    //     _merchant_account: &domain::MerchantAccount,\n    //     _key_store: &domain::MerchantKeyStore,\n    //     _business_profile: &domain::Profile,\n    //     _payment_method_data: Option<&domain::PaymentMethodData>,\n    //     _connector: api::ConnectorData,\n    //     _customer: &Option<domain::Customer>,\n    //     _payment_data: &mut D,\n    //     _call_connector_action: common_enums::CallConnectorAction,\n    // ) -> CustomResult<\n    //     hyperswitch_domain_models::router_data::RouterData<F, RouterDataReq, PaymentsResponseData>,\n    //     errors::ApiErrorResponse,\n    // > {\n    //     // TODO: raise an error here\n    //     todo!();\n    // }\n}",
+      "diff_span": {
+        "before": "        _merchant_account: &domain::Profile,\n        _key_store: &domain::MerchantKeyStore,\n        _authentication_product_ids: &common_types::payments::AuthenticationConnectorAccountMap,\n    ) -> CustomResult<(), errors::ApiErrorResponse> {\n        Ok(())",
+        "after": ""
+      },
+      "commit_sha": "2e791d5289a5eaf011722af0413bc64967acca19"
+    },
+    {
+      "id": "crates/router/src/core/payments.rs::function::payments_operation_core",
+      "file": "crates/router/src/core/payments.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn payments_operation_core<F, Req, Op, FData, D>(\n    state: &SessionState,\n    req_state: ReqState,\n    merchant_account: domain::MerchantAccount,\n    profile_id_from_auth_layer: Option<id_type::ProfileId>,\n    key_store: domain::MerchantKeyStore,\n    operation: Op,\n    req: Req,\n    call_connector_action: CallConnectorAction,\n    auth_flow: services::AuthFlow,\n    eligible_connectors: Option<Vec<common_enums::RoutableConnectors>>,\n    header_payload: HeaderPayload,\n) -> RouterResult<(D, Req, Option<domain::Customer>, Option<u16>, Option<u128>)>\nwhere\n    F: Send + Clone + Sync,\n    Req: Authenticate + Clone,\n    Op: Operation<F, Req, Data = D> + Send + Sync,\n    D: OperationSessionGetters<F> + OperationSessionSetters<F> + Send + Sync + Clone,\n\n    // To create connector flow specific interface data\n    D: ConstructFlowSpecificData<F, FData, router_types::PaymentsResponseData>,\n    RouterData<F, FData, router_types::PaymentsResponseData>: Feature<F, FData>,\n\n    // To construct connector flow specific api\n    dyn api::Connector:\n        services::api::ConnectorIntegration<F, FData, router_types::PaymentsResponseData>,\n\n    // To perform router related operation for PaymentResponse\n    PaymentResponse: Operation<F, FData, Data = D>,\n    FData: Send + Sync + Clone,\n{\n    let operation: BoxedOperation<'_, F, Req, D> = Box::new(operation);\n\n    tracing::Span::current().record(\"merchant_id\", merchant_account.get_id().get_string_repr());\n    let (operation, validate_result) = operation\n        .to_validate_request()?\n        .validate_request(&req, &merchant_account)?;\n\n    tracing::Span::current().record(\"payment_id\", format!(\"{}\", validate_result.payment_id));\n    // get profile from headers\n    let operations::GetTrackerResponse {\n        operation,\n        customer_details,\n        mut payment_data,\n        business_profile,\n        mandate_type,\n    } = operation\n        .to_get_tracker()?\n        .get_trackers(\n            state,\n            &validate_result.payment_id,\n            &req,\n            &merchant_account,\n            &key_store,\n            auth_flow,\n            &header_payload,\n        )\n        .await?;\n    core_utils::validate_profile_id_from_auth_layer(\n        profile_id_from_auth_layer,\n        &payment_data.get_payment_intent().clone(),\n    )?;\n\n    let (operation, customer) = operation\n        .to_domain()?\n        // get_customer_details\n        .get_or_create_customer_details(\n            state,\n            &mut payment_data,\n            customer_details,\n            &key_store,\n            merchant_account.storage_scheme,\n        )\n        .await\n        .to_not_found_response(errors::ApiErrorResponse::CustomerNotFound)\n        .attach_printable(\"Failed while fetching/creating customer\")?;\n\n    let authentication_type =\n        call_decision_manager(state, &merchant_account, &business_profile, &payment_data).await?;\n\n    payment_data.set_authentication_type_in_attempt(authentication_type);\n\n    let connector = get_connector_choice(\n        &operation,\n        state,\n        &req,\n        &merchant_account,\n        &business_profile,\n        &key_store,\n        &mut payment_data,\n        eligible_connectors,\n        mandate_type,\n    )\n    .await?;\n\n    let should_add_task_to_process_tracker = should_add_task_to_process_tracker(&payment_data);\n\n    let locale = header_payload.locale.clone();\n\n    payment_data = tokenize_in_router_when_confirm_false_or_external_authentication(\n        state,\n        &operation,\n        &mut payment_data,\n        &validate_result,\n        &key_store,\n        &customer,\n        &business_profile,\n    )\n    .await?;\n\n    let mut connector_http_status_code = None;\n    let mut external_latency = None;\n    if let Some(connector_details) = connector {\n        // Fetch and check FRM configs\n        #[cfg(feature = \"frm\")]\n        let mut frm_info = None;\n        #[allow(unused_variables, unused_mut)]\n        let mut should_continue_transaction: bool = true;\n        #[cfg(feature = \"frm\")]\n        let mut should_continue_capture: bool = true;\n        #[cfg(feature = \"frm\")]\n        let frm_configs = if state.conf.frm.enabled {\n            Box::pin(frm_core::call_frm_before_connector_call(\n                &operation,\n                &merchant_account,\n                &mut payment_data,\n                state,\n                &mut frm_info,\n                &customer,\n                &mut should_continue_transaction,\n                &mut should_continue_capture,\n                key_store.clone(),\n            ))\n            .await?\n        } else {\n            None\n        };\n        #[cfg(feature = \"frm\")]\n        logger::debug!(\n            \"frm_configs: {:?}\\nshould_continue_transaction: {:?}\\nshould_continue_capture: {:?}\",\n            frm_configs,\n            should_continue_transaction,\n            should_continue_capture,\n        );\n\n        if helpers::is_merchant_eligible_authenthention_service(merchant_account.get_id(), state)\n            .await?\n        {\n            let authentication_product_ids = business_profile\n                .authentication_product_ids\n                .clone()\n                .ok_or(errors::ApiErrorResponse::PreconditionFailed {\n                    message: \"authentication_product_ids is not configured in business profile\"\n                        .to_string(),\n                })?;\n            operation\n                .to_domain()?\n                .call_unified_authentication_service_if_eligible(\n                    state,\n                    &mut payment_data,\n                    &mut should_continue_transaction,\n                    &connector_details,\n                    &business_profile,\n                    &key_store,\n                    &authentication_product_ids,\n                )\n                .await?;\n        } else {\n            logger::info!(\n                \"skipping authentication service call since the merchant is not eligible.\"\n            );\n\n            operation\n                .to_domain()?\n                .call_external_three_ds_authentication_if_eligible(\n                    state,\n                    &mut payment_data,\n                    &mut should_continue_transaction,\n                    &connector_details,\n                    &business_profile,\n                    &key_store,\n                    mandate_type,\n                )\n                .await?;\n        };\n\n        operation\n            .to_domain()?\n            .payments_dynamic_tax_calculation(\n                state,\n                &mut payment_data,\n                &connector_details,\n                &business_profile,\n                &key_store,\n                &merchant_account,\n            )\n            .await?;\n\n        if should_continue_transaction {\n            #[cfg(feature = \"frm\")]\n            match (\n                should_continue_capture,\n                payment_data.get_payment_attempt().capture_method,\n            ) {\n                (\n                    false,\n                    Some(storage_enums::CaptureMethod::Automatic)\n                    | Some(storage_enums::CaptureMethod::SequentialAutomatic),\n                )\n                | (false, Some(storage_enums::CaptureMethod::Scheduled)) => {\n                    if let Some(info) = &mut frm_info {\n                        if let Some(frm_data) = &mut info.frm_data {\n                            frm_data.fraud_check.payment_capture_method =\n                                payment_data.get_payment_attempt().capture_method;\n                        }\n                    }\n                    payment_data\n                        .set_capture_method_in_attempt(storage_enums::CaptureMethod::Manual);\n                    logger::debug!(\"payment_id : {:?} capture method has been changed to manual, since it has configured Post FRM flow\",payment_data.get_payment_attempt().payment_id);\n                }\n                _ => (),\n            };\n            payment_data = match connector_details {\n                ConnectorCallType::PreDetermined(connector) => {\n                    #[cfg(all(feature = \"dynamic_routing\", feature = \"v1\"))]\n                    let routable_connectors =\n                        convert_connector_data_to_routable_connectors(&[connector.clone()])\n                            .map_err(|e| logger::error!(routable_connector_error=?e))\n                            .unwrap_or_default();\n                    let schedule_time = if should_add_task_to_process_tracker {\n                        payment_sync::get_sync_process_schedule_time(\n                            &*state.store,\n                            connector.connector.id(),\n                            merchant_account.get_id(),\n                            0,\n                        )\n                        .await\n                        .change_context(errors::ApiErrorResponse::InternalServerError)\n                        .attach_printable(\"Failed while getting process schedule time\")?\n                    } else {\n                        None\n                    };\n                    let (router_data, mca) = call_connector_service(\n                        state,\n                        req_state.clone(),\n                        &merchant_account,\n                        &key_store,\n                        connector.clone(),\n                        &operation,\n                        &mut payment_data,\n                        &customer,\n                        call_connector_action.clone(),\n                        &validate_result,\n                        schedule_time,\n                        header_payload.clone(),\n                        #[cfg(feature = \"frm\")]\n                        frm_info.as_ref().and_then(|fi| fi.suggested_action),\n                        #[cfg(not(feature = \"frm\"))]\n                        None,\n                        &business_profile,\n                        false,\n                    )\n                    .await?;\n\n                    let op_ref = &operation;\n                    let should_trigger_post_processing_flows = is_operation_confirm(&operation);\n\n                    let operation = Box::new(PaymentResponse);\n\n                    connector_http_status_code = router_data.connector_http_status_code;\n                    external_latency = router_data.external_latency;\n                    //add connector http status code metrics\n                    add_connector_http_status_code_metrics(connector_http_status_code);\n\n                    operation\n                        .to_post_update_tracker()?\n                        .save_pm_and_mandate(\n                            state,\n                            &router_data,\n                            &merchant_account,\n                            &key_store,\n                            &mut payment_data,\n                            &business_profile,\n                        )\n                        .await?;\n\n                    let mut payment_data = operation\n                        .to_post_update_tracker()?\n                        .update_tracker(\n                            state,\n                            payment_data,\n                            router_data,\n                            &key_store,\n                            merchant_account.storage_scheme,\n                            &locale,\n                            #[cfg(all(feature = \"dynamic_routing\", feature = \"v1\"))]\n                            routable_connectors,\n                            #[cfg(all(feature = \"dynamic_routing\", feature = \"v1\"))]\n                            &business_profile,\n                        )\n                        .await?;\n\n                    if should_trigger_post_processing_flows {\n                        complete_postprocessing_steps_if_required(\n                            state,\n                            &merchant_account,\n                            &key_store,\n                            &customer,\n                            &mca,\n                            &connector,\n                            &mut payment_data,\n                            op_ref,\n                            Some(header_payload.clone()),\n                        )\n                        .await?;\n                    }\n\n                    payment_data\n                }\n\n                ConnectorCallType::Retryable(connectors) => {\n                    #[cfg(all(feature = \"dynamic_routing\", feature = \"v1\"))]\n                    let routable_connectors =\n                        convert_connector_data_to_routable_connectors(&connectors)\n                            .map_err(|e| logger::error!(routable_connector_error=?e))\n                            .unwrap_or_default();\n\n                    let mut connectors = connectors.into_iter();\n\n                    let connector_data = get_connector_data(&mut connectors)?;\n\n                    let schedule_time = if should_add_task_to_process_tracker {\n                        payment_sync::get_sync_process_schedule_time(\n                            &*state.store,\n                            connector_data.connector.id(),\n                            merchant_account.get_id(),\n                            0,\n                        )\n                        .await\n                        .change_context(errors::ApiErrorResponse::InternalServerError)\n                        .attach_printable(\"Failed while getting process schedule time\")?\n                    } else {\n                        None\n                    };\n                    let (router_data, mca) = call_connector_service(\n                        state,\n                        req_state.clone(),\n                        &merchant_account,\n                        &key_store,\n                        connector_data.clone(),\n                        &operation,\n                        &mut payment_data,\n                        &customer,\n                        call_connector_action.clone(),\n                        &validate_result,\n                        schedule_time,\n                        header_payload.clone(),\n                        #[cfg(feature = \"frm\")]\n                        frm_info.as_ref().and_then(|fi| fi.suggested_action),\n                        #[cfg(not(feature = \"frm\"))]\n                        None,\n                        &business_profile,\n                        false,\n                    )\n                    .await?;\n\n                    #[cfg(all(feature = \"retry\", feature = \"v1\"))]\n                    let mut router_data = router_data;\n                    #[cfg(all(feature = \"retry\", feature = \"v1\"))]\n                    {\n                        use crate::core::payments::retry::{self, GsmValidation};\n                        let config_bool = retry::config_should_call_gsm(\n                            &*state.store,\n                            merchant_account.get_id(),\n                            &business_profile,\n                        )\n                        .await;\n\n                        if config_bool && router_data.should_call_gsm() {\n                            router_data = retry::do_gsm_actions(\n                                state,\n                                req_state.clone(),\n                                &mut payment_data,\n                                connectors,\n                                connector_data.clone(),\n                                router_data,\n                                &merchant_account,\n                                &key_store,\n                                &operation,\n                                &customer,\n                                &validate_result,\n                                schedule_time,\n                                #[cfg(feature = \"frm\")]\n                                frm_info.as_ref().and_then(|fi| fi.suggested_action),\n                                #[cfg(not(feature = \"frm\"))]\n                                None,\n                                &business_profile,\n                            )\n                            .await?;\n                        };\n                    }\n\n                    let op_ref = &operation;\n                    let should_trigger_post_processing_flows = is_operation_confirm(&operation);\n\n                    let operation = Box::new(PaymentResponse);\n                    connector_http_status_code = router_data.connector_http_status_code;\n                    external_latency = router_data.external_latency;\n                    //add connector http status code metrics\n                    add_connector_http_status_code_metrics(connector_http_status_code);\n\n                    operation\n                        .to_post_update_tracker()?\n                        .save_pm_and_mandate(\n                            state,\n                            &router_data,\n                            &merchant_account,\n                            &key_store,\n                            &mut payment_data,\n                            &business_profile,\n                        )\n                        .await?;\n\n                    let mut payment_data = operation\n                        .to_post_update_tracker()?\n                        .update_tracker(\n                            state,\n                            payment_data,\n                            router_data,\n                            &key_store,\n                            merchant_account.storage_scheme,\n                            &locale,\n                            #[cfg(all(feature = \"dynamic_routing\", feature = \"v1\"))]\n                            routable_connectors,\n                            #[cfg(all(feature = \"dynamic_routing\", feature = \"v1\"))]\n                            &business_profile,\n                        )\n                        .await?;\n\n                    if should_trigger_post_processing_flows {\n                        complete_postprocessing_steps_if_required(\n                            state,\n                            &merchant_account,\n                            &key_store,\n                            &customer,\n                            &mca,\n                            &connector_data,\n                            &mut payment_data,\n                            op_ref,\n                            Some(header_payload.clone()),\n                        )\n                        .await?;\n                    }\n\n                    payment_data\n                }\n\n                ConnectorCallType::SessionMultiple(connectors) => {\n                    let session_surcharge_details =\n                        call_surcharge_decision_management_for_session_flow(\n                            state,\n                            &merchant_account,\n                            &business_profile,\n                            payment_data.get_payment_attempt(),\n                            payment_data.get_payment_intent(),\n                            payment_data.get_billing_address(),\n                            &connectors,\n                        )\n                        .await?;\n                    Box::pin(call_multiple_connectors_service(\n                        state,\n                        &merchant_account,\n                        &key_store,\n                        connectors,\n                        &operation,\n                        payment_data,\n                        &customer,\n                        session_surcharge_details,\n                        &business_profile,\n                        header_payload.clone(),\n                    ))\n                    .await?\n                }\n            };\n\n            #[cfg(feature = \"frm\")]\n            if let Some(fraud_info) = &mut frm_info {\n                #[cfg(feature = \"v1\")]\n                Box::pin(frm_core::post_payment_frm_core(\n                    state,\n                    req_state,\n                    &merchant_account,\n                    &mut payment_data,\n                    fraud_info,\n                    frm_configs\n                        .clone()\n                        .ok_or(errors::ApiErrorResponse::MissingRequiredField {\n                            field_name: \"frm_configs\",\n                        })\n                        .attach_printable(\"Frm configs label not found\")?,\n                    &customer,\n                    key_store.clone(),\n                    &mut should_continue_capture,\n                ))\n                .await?;\n            }\n        } else {\n            (_, payment_data) = operation\n                .to_update_tracker()?\n                .update_trackers(\n                    state,\n                    req_state,\n                    payment_data.clone(),\n                    customer.clone(),\n                    validate_result.storage_scheme,\n                    None,\n                    &key_store,\n                    #[cfg(feature = \"frm\")]\n                    frm_info.and_then(|info| info.suggested_action),\n                    #[cfg(not(feature = \"frm\"))]\n                    None,\n                    header_payload.clone(),\n                )\n                .await?;\n        }\n\n        let payment_intent_status = payment_data.get_payment_intent().status;\n\n        payment_data\n            .get_payment_attempt()\n            .payment_token\n            .as_ref()\n            .zip(payment_data.get_payment_attempt().payment_method)\n            .map(ParentPaymentMethodToken::create_key_for_token)\n            .async_map(|key_for_hyperswitch_token| async move {\n                if key_for_hyperswitch_token\n                    .should_delete_payment_method_token(payment_intent_status)\n                {\n                    let _ = key_for_hyperswitch_token.delete(state).await;\n                }\n            })\n            .await;\n    } else {\n        (_, payment_data) = operation\n            .to_update_tracker()?\n            .update_trackers(\n                state,\n                req_state,\n                payment_data.clone(),\n                customer.clone(),\n                validate_result.storage_scheme,\n                None,\n                &key_store,\n                None,\n                header_payload.clone(),\n            )\n            .await?;\n    }\n\n    let cloned_payment_data = payment_data.clone();\n    let cloned_customer = customer.clone();\n\n    #[cfg(feature = \"v1\")]\n    operation\n        .to_domain()?\n        .store_extended_card_info_temporarily(\n            state,\n            payment_data.get_payment_intent().get_id(),\n            &business_profile,\n            payment_data.get_payment_method_data(),\n        )\n        .await?;\n\n    utils::trigger_payments_webhook(\n        merchant_account,\n        business_profile,\n        &key_store,\n        cloned_payment_data,\n        cloned_customer,\n        state,\n        operation,\n    )\n    .await\n    .map_err(|error| logger::warn!(payments_outgoing_webhook_error=?error))\n    .ok();\n\n    Ok((\n        payment_data,\n        req,\n        customer,\n        connector_http_status_code,\n        external_latency,\n    ))\n}",
+      "after_code": "pub async fn payments_operation_core<F, Req, Op, FData, D>(\n    state: &SessionState,\n    req_state: ReqState,\n    merchant_account: domain::MerchantAccount,\n    profile_id_from_auth_layer: Option<id_type::ProfileId>,\n    key_store: domain::MerchantKeyStore,\n    operation: Op,\n    req: Req,\n    call_connector_action: CallConnectorAction,\n    auth_flow: services::AuthFlow,\n    eligible_connectors: Option<Vec<common_enums::RoutableConnectors>>,\n    header_payload: HeaderPayload,\n) -> RouterResult<(D, Req, Option<domain::Customer>, Option<u16>, Option<u128>)>\nwhere\n    F: Send + Clone + Sync,\n    Req: Authenticate + Clone,\n    Op: Operation<F, Req, Data = D> + Send + Sync,\n    D: OperationSessionGetters<F> + OperationSessionSetters<F> + Send + Sync + Clone,\n\n    // To create connector flow specific interface data\n    D: ConstructFlowSpecificData<F, FData, router_types::PaymentsResponseData>,\n    RouterData<F, FData, router_types::PaymentsResponseData>: Feature<F, FData>,\n\n    // To construct connector flow specific api\n    dyn api::Connector:\n        services::api::ConnectorIntegration<F, FData, router_types::PaymentsResponseData>,\n\n    // To perform router related operation for PaymentResponse\n    PaymentResponse: Operation<F, FData, Data = D>,\n    FData: Send + Sync + Clone,\n{\n    let operation: BoxedOperation<'_, F, Req, D> = Box::new(operation);\n\n    tracing::Span::current().record(\"merchant_id\", merchant_account.get_id().get_string_repr());\n    let (operation, validate_result) = operation\n        .to_validate_request()?\n        .validate_request(&req, &merchant_account)?;\n\n    tracing::Span::current().record(\"payment_id\", format!(\"{}\", validate_result.payment_id));\n    // get profile from headers\n    let operations::GetTrackerResponse {\n        operation,\n        customer_details,\n        mut payment_data,\n        business_profile,\n        mandate_type,\n    } = operation\n        .to_get_tracker()?\n        .get_trackers(\n            state,\n            &validate_result.payment_id,\n            &req,\n            &merchant_account,\n            &key_store,\n            auth_flow,\n            &header_payload,\n        )\n        .await?;\n    core_utils::validate_profile_id_from_auth_layer(\n        profile_id_from_auth_layer,\n        &payment_data.get_payment_intent().clone(),\n    )?;\n\n    let (operation, customer) = operation\n        .to_domain()?\n        // get_customer_details\n        .get_or_create_customer_details(\n            state,\n            &mut payment_data,\n            customer_details,\n            &key_store,\n            merchant_account.storage_scheme,\n        )\n        .await\n        .to_not_found_response(errors::ApiErrorResponse::CustomerNotFound)\n        .attach_printable(\"Failed while fetching/creating customer\")?;\n\n    let authentication_type =\n        call_decision_manager(state, &merchant_account, &business_profile, &payment_data).await?;\n\n    payment_data.set_authentication_type_in_attempt(authentication_type);\n\n    let connector = get_connector_choice(\n        &operation,\n        state,\n        &req,\n        &merchant_account,\n        &business_profile,\n        &key_store,\n        &mut payment_data,\n        eligible_connectors,\n        mandate_type,\n    )\n    .await?;\n\n    let should_add_task_to_process_tracker = should_add_task_to_process_tracker(&payment_data);\n\n    let locale = header_payload.locale.clone();\n\n    payment_data = tokenize_in_router_when_confirm_false_or_external_authentication(\n        state,\n        &operation,\n        &mut payment_data,\n        &validate_result,\n        &key_store,\n        &customer,\n        &business_profile,\n    )\n    .await?;\n\n    let mut connector_http_status_code = None;\n    let mut external_latency = None;\n    if let Some(connector_details) = connector {\n        // Fetch and check FRM configs\n        #[cfg(feature = \"frm\")]\n        let mut frm_info = None;\n        #[allow(unused_variables, unused_mut)]\n        let mut should_continue_transaction: bool = true;\n        #[cfg(feature = \"frm\")]\n        let mut should_continue_capture: bool = true;\n        #[cfg(feature = \"frm\")]\n        let frm_configs = if state.conf.frm.enabled {\n            Box::pin(frm_core::call_frm_before_connector_call(\n                &operation,\n                &merchant_account,\n                &mut payment_data,\n                state,\n                &mut frm_info,\n                &customer,\n                &mut should_continue_transaction,\n                &mut should_continue_capture,\n                key_store.clone(),\n            ))\n            .await?\n        } else {\n            None\n        };\n        #[cfg(feature = \"frm\")]\n        logger::debug!(\n            \"frm_configs: {:?}\\nshould_continue_transaction: {:?}\\nshould_continue_capture: {:?}\",\n            frm_configs,\n            should_continue_transaction,\n            should_continue_capture,\n        );\n\n        if helpers::is_merchant_eligible_authenthention_service(merchant_account.get_id(), state)\n            .await?\n        {\n            operation\n                .to_domain()?\n                .call_unified_authentication_service_if_eligible(\n                    state,\n                    &mut payment_data,\n                    &mut should_continue_transaction,\n                    &connector_details,\n                    &business_profile,\n                    &key_store,\n                )\n                .await?;\n        } else {\n            logger::info!(\n                \"skipping authentication service call since the merchant is not eligible.\"\n            );\n\n            operation\n                .to_domain()?\n                .call_external_three_ds_authentication_if_eligible(\n                    state,\n                    &mut payment_data,\n                    &mut should_continue_transaction,\n                    &connector_details,\n                    &business_profile,\n                    &key_store,\n                    mandate_type,\n                )\n                .await?;\n        };\n\n        operation\n            .to_domain()?\n            .payments_dynamic_tax_calculation(\n                state,\n                &mut payment_data,\n                &connector_details,\n                &business_profile,\n                &key_store,\n                &merchant_account,\n            )\n            .await?;\n\n        if should_continue_transaction {\n            #[cfg(feature = \"frm\")]\n            match (\n                should_continue_capture,\n                payment_data.get_payment_attempt().capture_method,\n            ) {\n                (\n                    false,\n                    Some(storage_enums::CaptureMethod::Automatic)\n                    | Some(storage_enums::CaptureMethod::SequentialAutomatic),\n                )\n                | (false, Some(storage_enums::CaptureMethod::Scheduled)) => {\n                    if let Some(info) = &mut frm_info {\n                        if let Some(frm_data) = &mut info.frm_data {\n                            frm_data.fraud_check.payment_capture_method =\n                                payment_data.get_payment_attempt().capture_method;\n                        }\n                    }\n                    payment_data\n                        .set_capture_method_in_attempt(storage_enums::CaptureMethod::Manual);\n                    logger::debug!(\"payment_id : {:?} capture method has been changed to manual, since it has configured Post FRM flow\",payment_data.get_payment_attempt().payment_id);\n                }\n                _ => (),\n            };\n            payment_data = match connector_details {\n                ConnectorCallType::PreDetermined(connector) => {\n                    #[cfg(all(feature = \"dynamic_routing\", feature = \"v1\"))]\n                    let routable_connectors =\n                        convert_connector_data_to_routable_connectors(&[connector.clone()])\n                            .map_err(|e| logger::error!(routable_connector_error=?e))\n                            .unwrap_or_default();\n                    let schedule_time = if should_add_task_to_process_tracker {\n                        payment_sync::get_sync_process_schedule_time(\n                            &*state.store,\n                            connector.connector.id(),\n                            merchant_account.get_id(),\n                            0,\n                        )\n                        .await\n                        .change_context(errors::ApiErrorResponse::InternalServerError)\n                        .attach_printable(\"Failed while getting process schedule time\")?\n                    } else {\n                        None\n                    };\n                    let (router_data, mca) = call_connector_service(\n                        state,\n                        req_state.clone(),\n                        &merchant_account,\n                        &key_store,\n                        connector.clone(),\n                        &operation,\n                        &mut payment_data,\n                        &customer,\n                        call_connector_action.clone(),\n                        &validate_result,\n                        schedule_time,\n                        header_payload.clone(),\n                        #[cfg(feature = \"frm\")]\n                        frm_info.as_ref().and_then(|fi| fi.suggested_action),\n                        #[cfg(not(feature = \"frm\"))]\n                        None,\n                        &business_profile,\n                        false,\n                    )\n                    .await?;\n\n                    let op_ref = &operation;\n                    let should_trigger_post_processing_flows = is_operation_confirm(&operation);\n\n                    let operation = Box::new(PaymentResponse);\n\n                    connector_http_status_code = router_data.connector_http_status_code;\n                    external_latency = router_data.external_latency;\n                    //add connector http status code metrics\n                    add_connector_http_status_code_metrics(connector_http_status_code);\n\n                    operation\n                        .to_post_update_tracker()?\n                        .save_pm_and_mandate(\n                            state,\n                            &router_data,\n                            &merchant_account,\n                            &key_store,\n                            &mut payment_data,\n                            &business_profile,\n                        )\n                        .await?;\n\n                    let mut payment_data = operation\n                        .to_post_update_tracker()?\n                        .update_tracker(\n                            state,\n                            payment_data,\n                            router_data,\n                            &key_store,\n                            merchant_account.storage_scheme,\n                            &locale,\n                            #[cfg(all(feature = \"dynamic_routing\", feature = \"v1\"))]\n                            routable_connectors,\n                            #[cfg(all(feature = \"dynamic_routing\", feature = \"v1\"))]\n                            &business_profile,\n                        )\n                        .await?;\n\n                    if should_trigger_post_processing_flows {\n                        complete_postprocessing_steps_if_required(\n                            state,\n                            &merchant_account,\n                            &key_store,\n                            &customer,\n                            &mca,\n                            &connector,\n                            &mut payment_data,\n                            op_ref,\n                            Some(header_payload.clone()),\n                        )\n                        .await?;\n                    }\n\n                    payment_data\n                }\n\n                ConnectorCallType::Retryable(connectors) => {\n                    #[cfg(all(feature = \"dynamic_routing\", feature = \"v1\"))]\n                    let routable_connectors =\n                        convert_connector_data_to_routable_connectors(&connectors)\n                            .map_err(|e| logger::error!(routable_connector_error=?e))\n                            .unwrap_or_default();\n\n                    let mut connectors = connectors.into_iter();\n\n                    let connector_data = get_connector_data(&mut connectors)?;\n\n                    let schedule_time = if should_add_task_to_process_tracker {\n                        payment_sync::get_sync_process_schedule_time(\n                            &*state.store,\n                            connector_data.connector.id(),\n                            merchant_account.get_id(),\n                            0,\n                        )\n                        .await\n                        .change_context(errors::ApiErrorResponse::InternalServerError)\n                        .attach_printable(\"Failed while getting process schedule time\")?\n                    } else {\n                        None\n                    };\n                    let (router_data, mca) = call_connector_service(\n                        state,\n                        req_state.clone(),\n                        &merchant_account,\n                        &key_store,\n                        connector_data.clone(),\n                        &operation,\n                        &mut payment_data,\n                        &customer,\n                        call_connector_action.clone(),\n                        &validate_result,\n                        schedule_time,\n                        header_payload.clone(),\n                        #[cfg(feature = \"frm\")]\n                        frm_info.as_ref().and_then(|fi| fi.suggested_action),\n                        #[cfg(not(feature = \"frm\"))]\n                        None,\n                        &business_profile,\n                        false,\n                    )\n                    .await?;\n\n                    #[cfg(all(feature = \"retry\", feature = \"v1\"))]\n                    let mut router_data = router_data;\n                    #[cfg(all(feature = \"retry\", feature = \"v1\"))]\n                    {\n                        use crate::core::payments::retry::{self, GsmValidation};\n                        let config_bool = retry::config_should_call_gsm(\n                            &*state.store,\n                            merchant_account.get_id(),\n                            &business_profile,\n                        )\n                        .await;\n\n                        if config_bool && router_data.should_call_gsm() {\n                            router_data = retry::do_gsm_actions(\n                                state,\n                                req_state.clone(),\n                                &mut payment_data,\n                                connectors,\n                                connector_data.clone(),\n                                router_data,\n                                &merchant_account,\n                                &key_store,\n                                &operation,\n                                &customer,\n                                &validate_result,\n                                schedule_time,\n                                #[cfg(feature = \"frm\")]\n                                frm_info.as_ref().and_then(|fi| fi.suggested_action),\n                                #[cfg(not(feature = \"frm\"))]\n                                None,\n                                &business_profile,\n                            )\n                            .await?;\n                        };\n                    }\n\n                    let op_ref = &operation;\n                    let should_trigger_post_processing_flows = is_operation_confirm(&operation);\n\n                    let operation = Box::new(PaymentResponse);\n                    connector_http_status_code = router_data.connector_http_status_code;\n                    external_latency = router_data.external_latency;\n                    //add connector http status code metrics\n                    add_connector_http_status_code_metrics(connector_http_status_code);\n\n                    operation\n                        .to_post_update_tracker()?\n                        .save_pm_and_mandate(\n                            state,\n                            &router_data,\n                            &merchant_account,\n                            &key_store,\n                            &mut payment_data,\n                            &business_profile,\n                        )\n                        .await?;\n\n                    let mut payment_data = operation\n                        .to_post_update_tracker()?\n                        .update_tracker(\n                            state,\n                            payment_data,\n                            router_data,\n                            &key_store,\n                            merchant_account.storage_scheme,\n                            &locale,\n                            #[cfg(all(feature = \"dynamic_routing\", feature = \"v1\"))]\n                            routable_connectors,\n                            #[cfg(all(feature = \"dynamic_routing\", feature = \"v1\"))]\n                            &business_profile,\n                        )\n                        .await?;\n\n                    if should_trigger_post_processing_flows {\n                        complete_postprocessing_steps_if_required(\n                            state,\n                            &merchant_account,\n                            &key_store,\n                            &customer,\n                            &mca,\n                            &connector_data,\n                            &mut payment_data,\n                            op_ref,\n                            Some(header_payload.clone()),\n                        )\n                        .await?;\n                    }\n\n                    payment_data\n                }\n\n                ConnectorCallType::SessionMultiple(connectors) => {\n                    let session_surcharge_details =\n                        call_surcharge_decision_management_for_session_flow(\n                            state,\n                            &merchant_account,\n                            &business_profile,\n                            payment_data.get_payment_attempt(),\n                            payment_data.get_payment_intent(),\n                            payment_data.get_billing_address(),\n                            &connectors,\n                        )\n                        .await?;\n                    Box::pin(call_multiple_connectors_service(\n                        state,\n                        &merchant_account,\n                        &key_store,\n                        connectors,\n                        &operation,\n                        payment_data,\n                        &customer,\n                        session_surcharge_details,\n                        &business_profile,\n                        header_payload.clone(),\n                    ))\n                    .await?\n                }\n            };\n\n            #[cfg(feature = \"frm\")]\n            if let Some(fraud_info) = &mut frm_info {\n                #[cfg(feature = \"v1\")]\n                Box::pin(frm_core::post_payment_frm_core(\n                    state,\n                    req_state,\n                    &merchant_account,\n                    &mut payment_data,\n                    fraud_info,\n                    frm_configs\n                        .clone()\n                        .ok_or(errors::ApiErrorResponse::MissingRequiredField {\n                            field_name: \"frm_configs\",\n                        })\n                        .attach_printable(\"Frm configs label not found\")?,\n                    &customer,\n                    key_store.clone(),\n                    &mut should_continue_capture,\n                ))\n                .await?;\n            }\n        } else {\n            (_, payment_data) = operation\n                .to_update_tracker()?\n                .update_trackers(\n                    state,\n                    req_state,\n                    payment_data.clone(),\n                    customer.clone(),\n                    validate_result.storage_scheme,\n                    None,\n                    &key_store,\n                    #[cfg(feature = \"frm\")]\n                    frm_info.and_then(|info| info.suggested_action),\n                    #[cfg(not(feature = \"frm\"))]\n                    None,\n                    header_payload.clone(),\n                )\n                .await?;\n        }\n\n        let payment_intent_status = payment_data.get_payment_intent().status;\n\n        payment_data\n            .get_payment_attempt()\n            .payment_token\n            .as_ref()\n            .zip(payment_data.get_payment_attempt().payment_method)\n            .map(ParentPaymentMethodToken::create_key_for_token)\n            .async_map(|key_for_hyperswitch_token| async move {\n                if key_for_hyperswitch_token\n                    .should_delete_payment_method_token(payment_intent_status)\n                {\n                    let _ = key_for_hyperswitch_token.delete(state).await;\n                }\n            })\n            .await;\n    } else {\n        (_, payment_data) = operation\n            .to_update_tracker()?\n            .update_trackers(\n                state,\n                req_state,\n                payment_data.clone(),\n                customer.clone(),\n                validate_result.storage_scheme,\n                None,\n                &key_store,\n                None,\n                header_payload.clone(),\n            )\n            .await?;\n    }\n\n    let cloned_payment_data = payment_data.clone();\n    let cloned_customer = customer.clone();\n\n    #[cfg(feature = \"v1\")]\n    operation\n        .to_domain()?\n        .store_extended_card_info_temporarily(\n            state,\n            payment_data.get_payment_intent().get_id(),\n            &business_profile,\n            payment_data.get_payment_method_data(),\n        )\n        .await?;\n\n    utils::trigger_payments_webhook(\n        merchant_account,\n        business_profile,\n        &key_store,\n        cloned_payment_data,\n        cloned_customer,\n        state,\n        operation,\n    )\n    .await\n    .map_err(|error| logger::warn!(payments_outgoing_webhook_error=?error))\n    .ok();\n\n    Ok((\n        payment_data,\n        req,\n        customer,\n        connector_http_status_code,\n        external_latency,\n    ))\n}",
+      "diff_span": {
+        "before": "            .await?\n        {\n            let authentication_product_ids = business_profile\n                .authentication_product_ids\n                .clone()\n                .ok_or(errors::ApiErrorResponse::PreconditionFailed {\n                    message: \"authentication_product_ids is not configured in business profile\"\n                        .to_string(),\n                })?;\n            operation\n                .to_domain()?\n                .call_unified_authentication_service_if_eligible(\n                    state,\n                    &mut payment_data,\n                    &mut should_continue_transaction,\n                    &connector_details,\n                    &business_profile,\n                    &key_store,\n                    &authentication_product_ids,\n                )\n                .await?;",
+        "after": ""
+      },
+      "commit_sha": "2e791d5289a5eaf011722af0413bc64967acca19"
+    },
+    {
+      "id": "crates/router/src/core/payments/helpers.rs::function::is_merchant_eligible_authenthention_service",
+      "file": "crates/router/src/core/payments/helpers.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": true,
+      "before_code": "pub async fn is_merchant_eligible_authenthention_service(\n    merchant_id: &id_type::MerchantId,\n    state: &SessionState,\n) -> RouterResult<bool> {\n    let merchants_eligible_for_authentication_service = state\n        .store\n        .as_ref()\n        .find_config_by_key(consts::AUTHENTICATION_SERVICE_ELIGIBLE_CONFIG)\n        .await\n        .to_not_found_response(errors::ApiErrorResponse::ConfigNotFound)?;\n\n    let auth_eligible_array: Vec<String> =\n        serde_json::from_str(&merchants_eligible_for_authentication_service.config)\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"unable to parse authentication service config\")?;\n\n    Ok(auth_eligible_array.contains(&merchant_id.get_string_repr().to_owned()))\n}",
+      "after_code": "pub async fn is_merchant_eligible_authenthention_service(\n    merchant_id: &id_type::MerchantId,\n    state: &SessionState,\n) -> RouterResult<bool> {\n    let merchants_eligible_for_authentication_service = state\n        .store\n        .as_ref()\n        .find_config_by_key_unwrap_or(\n            consts::AUTHENTICATION_SERVICE_ELIGIBLE_CONFIG,\n            Some(\"[]\".to_string()),\n        )\n        .await;\n\n    let auth_eligible_array: Vec<String> = match merchants_eligible_for_authentication_service {\n        Ok(config) => serde_json::from_str(&config.config)\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"unable to parse authentication service config\")?,\n        Err(err) => {\n            if !err.current_context().is_db_not_found() {\n                logger::error!(\n                    \"Error fetching authentication service enabled merchant config {:?}\",\n                    err\n                );\n            }\n            Vec::new()\n        }\n    };\n\n    Ok(auth_eligible_array.contains(&merchant_id.get_string_repr().to_owned()))\n}",
+      "diff_span": {
+        "before": "        .store\n        .as_ref()\n        .find_config_by_key(consts::AUTHENTICATION_SERVICE_ELIGIBLE_CONFIG)\n        .await\n        .to_not_found_response(errors::ApiErrorResponse::ConfigNotFound)?;\n\n    let auth_eligible_array: Vec<String> =\n        serde_json::from_str(&merchants_eligible_for_authentication_service.config)\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"unable to parse authentication service config\")?;\n\n    Ok(auth_eligible_array.contains(&merchant_id.get_string_repr().to_owned()))",
+        "after": "        .store\n        .as_ref()\n        .find_config_by_key_unwrap_or(\n            consts::AUTHENTICATION_SERVICE_ELIGIBLE_CONFIG,\n            Some(\"[]\".to_string()),\n        )\n        .await;\n\n    let auth_eligible_array: Vec<String> = match merchants_eligible_for_authentication_service {\n        Ok(config) => serde_json::from_str(&config.config)\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"unable to parse authentication service config\")?,\n        Err(err) => {\n            if !err.current_context().is_db_not_found() {\n                logger::error!(\n                    \"Error fetching authentication service enabled merchant config {:?}\",\n                    err\n                );\n            }\n            Vec::new()\n        }\n    };\n\n    Ok(auth_eligible_array.contains(&merchant_id.get_string_repr().to_owned()))"
+      },
+      "commit_sha": "2e791d5289a5eaf011722af0413bc64967acca19",
+      "before_imports": [
+        "use openssl::{\n    derive::Deriver,\n    pkey::PKey,\n    symm::{decrypt_aead, Cipher},\n};",
+        "use api_models::{\n    mandates::RecurringDetails,\n    payments::{additional_info as payment_additional_types, RequestSurchargeDetails},\n};",
+        "use super::{\n    operations::{BoxedOperation, Operation, PaymentResponse},\n    CustomerDetails, PaymentData,\n};",
+        "use crate::{\n    configs::settings::{ConnectorRequestReferenceIdConfig, TempLockerEnableConfig},\n    connector,\n    consts::{self, BASE64_ENGINE},\n    core::{\n        authentication,\n        errors::{self, CustomResult, RouterResult, StorageErrorExt},\n        mandate::helpers::MandateGenericData,\n        payment_methods::{\n            self,\n            cards::{self},\n            network_tokenization, vault,\n        },\n        payments,\n        pm_auth::retrieve_payment_method_from_auth_service,\n    },\n    db::StorageInterface,\n    routes::{metrics, payment_methods as payment_methods_handler, SessionState},\n    services,\n    types::{\n        api::{self, admin, enums as api_enums, MandateValidationFieldsExt},\n        domain::{self, types},\n        storage::{self, enums as storage_enums, ephemeral_key, CardTokenData},\n        transformers::{ForeignFrom, ForeignTryFrom},\n        AdditionalMerchantData, AdditionalPaymentMethodConnectorResponse, ErrorResponse,\n        MandateReference, MerchantAccountData, MerchantRecipientData, PaymentsResponseData,\n        RecipientIdType, RecurringMandatePaymentData, RouterData,\n    },\n    utils::{\n        self,\n        crypto::{self, SignMessage},\n        OptionExt, StringExt,\n    },\n};",
+        "use common_utils::{\n    crypto::Encryptable,\n    ext_traits::{AsyncExt, ByteSliceExt, Encode, ValueExt},\n    fp_utils, generate_id,\n    id_type::{self},\n    new_type::{MaskedIban, MaskedSortCode},\n    pii, type_name,\n    types::{\n        keymanager::{Identifier, KeyManagerState, ToEncryptable},\n        MinorUnit,\n    },\n};"
+      ],
+      "after_imports": [
+        "use openssl::{\n    derive::Deriver,\n    pkey::PKey,\n    symm::{decrypt_aead, Cipher},\n};",
+        "use api_models::{\n    mandates::RecurringDetails,\n    payments::{additional_info as payment_additional_types, RequestSurchargeDetails},\n};",
+        "use super::{\n    operations::{BoxedOperation, Operation, PaymentResponse},\n    CustomerDetails, PaymentData,\n};",
+        "use router_env::{instrument, logger, tracing};",
+        "use crate::{\n    configs::settings::{ConnectorRequestReferenceIdConfig, TempLockerEnableConfig},\n    connector,\n    consts::{self, BASE64_ENGINE},\n    core::{\n        authentication,\n        errors::{self, CustomResult, RouterResult, StorageErrorExt},\n        mandate::helpers::MandateGenericData,\n        payment_methods::{\n            self,\n            cards::{self},\n            network_tokenization, vault,\n        },\n        payments,\n        pm_auth::retrieve_payment_method_from_auth_service,\n    },\n    db::StorageInterface,\n    routes::{metrics, payment_methods as payment_methods_handler, SessionState},\n    services,\n    types::{\n        api::{self, admin, enums as api_enums, MandateValidationFieldsExt},\n        domain::{self, types},\n        storage::{self, enums as storage_enums, ephemeral_key, CardTokenData},\n        transformers::{ForeignFrom, ForeignTryFrom},\n        AdditionalMerchantData, AdditionalPaymentMethodConnectorResponse, ErrorResponse,\n        MandateReference, MerchantAccountData, MerchantRecipientData, PaymentsResponseData,\n        RecipientIdType, RecurringMandatePaymentData, RouterData,\n    },\n    utils::{\n        self,\n        crypto::{self, SignMessage},\n        OptionExt, StringExt,\n    },\n};",
+        "use common_utils::{\n    crypto::Encryptable,\n    ext_traits::{AsyncExt, ByteSliceExt, Encode, ValueExt},\n    fp_utils, generate_id,\n    id_type::{self},\n    new_type::{MaskedIban, MaskedSortCode},\n    pii, type_name,\n    types::{\n        keymanager::{Identifier, KeyManagerState, ToEncryptable},\n        MinorUnit,\n    },\n};"
+      ]
+    },
+    {
+      "id": "crates/router/src/core/payments/operations/payment_confirm.rs::PaymentConfirm::function::call_unified_authentication_service_if_eligible",
+      "file": "crates/router/src/core/payments/operations/payment_confirm.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "async fn call_unified_authentication_service_if_eligible<'a>(\n        &'a self,\n        state: &SessionState,\n        payment_data: &mut PaymentData<F>,\n        _should_continue_confirm_transaction: &mut bool,\n        _connector_call_type: &ConnectorCallType,\n        business_profile: &domain::Profile,\n        key_store: &domain::MerchantKeyStore,\n        authentication_product_ids: &common_types::payments::AuthenticationConnectorAccountMap,\n    ) -> CustomResult<(), errors::ApiErrorResponse> {\n        if let Some(payment_method) = payment_data.payment_attempt.payment_method {\n            if payment_method == storage_enums::PaymentMethod::Card\n                && business_profile.is_click_to_pay_enabled\n            {\n                let click_to_pay_mca_id = authentication_product_ids\n                    .get_click_to_pay_connector_account_id()\n                    .change_context(errors::ApiErrorResponse::MissingRequiredField {\n                        field_name: \"authentication_product_ids\",\n                    })?;\n\n                let key_manager_state = &(state).into();\n                let merchant_id = &business_profile.merchant_id;\n\n                let connector_mca = state\n                    .store\n                    .find_by_merchant_connector_account_merchant_id_merchant_connector_id(\n                        key_manager_state,\n                        merchant_id,\n                        &click_to_pay_mca_id,\n                        key_store,\n                    )\n                    .await\n                    .to_not_found_response(\n                        errors::ApiErrorResponse::MerchantConnectorAccountNotFound {\n                            id: click_to_pay_mca_id.get_string_repr().to_string(),\n                        },\n                    )?;\n\n                let authentication_id =\n                    common_utils::generate_id_with_default_len(consts::AUTHENTICATION_ID_PREFIX);\n\n                let payment_method = payment_data.payment_attempt.payment_method.ok_or(\n                    errors::ApiErrorResponse::MissingRequiredField {\n                        field_name: \"payment_method\",\n                    },\n                )?;\n\n                ClickToPay::pre_authentication(\n                    state,\n                    key_store,\n                    business_profile,\n                    payment_data,\n                    &connector_mca,\n                    &connector_mca.connector_name,\n                    &authentication_id,\n                    payment_method,\n                )\n                .await?;\n\n                payment_data.payment_attempt.authentication_id = Some(authentication_id.clone());\n\n                let response = ClickToPay::post_authentication(\n                    state,\n                    key_store,\n                    business_profile,\n                    payment_data,\n                    &connector_mca,\n                    &connector_mca.connector_name,\n                    payment_method,\n                )\n                .await?;\n\n                let (network_token, authentication_status) = match response.response.clone() {\n                    Ok(unified_authentication_service::UasAuthenticationResponseData::PostAuthentication {\n                        authentication_details,\n                    }) => {\n                        (Some(\n                            hyperswitch_domain_models::payment_method_data::NetworkTokenData {\n                                token_number: authentication_details.token_details.payment_token,\n                                token_exp_month: authentication_details\n                                    .token_details\n                                    .token_expiration_month,\n                                token_exp_year: authentication_details\n                                    .token_details\n                                    .token_expiration_year,\n                                token_cryptogram: authentication_details\n                                    .dynamic_data_details\n                                    .and_then(|data| data.dynamic_data_value),\n                                card_issuer: None,\n                                card_network: None,\n                                card_type: None,\n                                card_issuing_country: None,\n                                bank_code: None,\n                                nick_name: None,\n                                eci: authentication_details.eci,\n                            }),common_enums::AuthenticationStatus::Success)\n                    },\n                    Ok(unified_authentication_service::UasAuthenticationResponseData::PreAuthentication {}) => (None, common_enums::AuthenticationStatus::Started),\n                    Err(_) => (None, common_enums::AuthenticationStatus::Failed)\n                };\n\n                payment_data.payment_attempt.payment_method =\n                    Some(common_enums::PaymentMethod::Card);\n\n                payment_data.payment_method_data = network_token\n                    .clone()\n                    .map(domain::PaymentMethodData::NetworkToken);\n\n                uas_utils::create_new_authentication(\n                    state,\n                    payment_data.payment_attempt.merchant_id.clone(),\n                    connector_mca.connector_name.to_string(),\n                    business_profile.get_id().clone(),\n                    Some(payment_data.payment_intent.get_id().clone()),\n                    click_to_pay_mca_id.to_owned(),\n                    &authentication_id,\n                    payment_data.service_details.clone(),\n                    authentication_status,\n                )\n                .await?;\n            }\n        }\n        logger::info!(\"skipping unified authentication service call since payment conditions {:?}, {:?} are not satisfied\", payment_data.payment_attempt.payment_method, business_profile.is_click_to_pay_enabled);\n        Ok(())\n    }",
+      "after_code": "async fn call_unified_authentication_service_if_eligible<'a>(\n        &'a self,\n        state: &SessionState,\n        payment_data: &mut PaymentData<F>,\n        _should_continue_confirm_transaction: &mut bool,\n        _connector_call_type: &ConnectorCallType,\n        business_profile: &domain::Profile,\n        key_store: &domain::MerchantKeyStore,\n    ) -> CustomResult<(), errors::ApiErrorResponse> {\n        let authentication_product_ids = business_profile\n            .authentication_product_ids\n            .clone()\n            .ok_or(errors::ApiErrorResponse::PreconditionFailed {\n                message: \"authentication_product_ids is not configured in business profile\"\n                    .to_string(),\n            })?;\n\n        if let Some(payment_method) = payment_data.payment_attempt.payment_method {\n            if payment_method == storage_enums::PaymentMethod::Card\n                && business_profile.is_click_to_pay_enabled\n            {\n                let click_to_pay_mca_id = authentication_product_ids\n                    .get_click_to_pay_connector_account_id()\n                    .change_context(errors::ApiErrorResponse::MissingRequiredField {\n                        field_name: \"authentication_product_ids\",\n                    })?;\n\n                let key_manager_state = &(state).into();\n                let merchant_id = &business_profile.merchant_id;\n\n                let connector_mca = state\n                    .store\n                    .find_by_merchant_connector_account_merchant_id_merchant_connector_id(\n                        key_manager_state,\n                        merchant_id,\n                        &click_to_pay_mca_id,\n                        key_store,\n                    )\n                    .await\n                    .to_not_found_response(\n                        errors::ApiErrorResponse::MerchantConnectorAccountNotFound {\n                            id: click_to_pay_mca_id.get_string_repr().to_string(),\n                        },\n                    )?;\n\n                let authentication_id =\n                    common_utils::generate_id_with_default_len(consts::AUTHENTICATION_ID_PREFIX);\n\n                let payment_method = payment_data.payment_attempt.payment_method.ok_or(\n                    errors::ApiErrorResponse::MissingRequiredField {\n                        field_name: \"payment_method\",\n                    },\n                )?;\n\n                ClickToPay::pre_authentication(\n                    state,\n                    key_store,\n                    business_profile,\n                    payment_data,\n                    &connector_mca,\n                    &connector_mca.connector_name,\n                    &authentication_id,\n                    payment_method,\n                )\n                .await?;\n\n                payment_data.payment_attempt.authentication_id = Some(authentication_id.clone());\n\n                let response = ClickToPay::post_authentication(\n                    state,\n                    key_store,\n                    business_profile,\n                    payment_data,\n                    &connector_mca,\n                    &connector_mca.connector_name,\n                    payment_method,\n                )\n                .await?;\n\n                let (network_token, authentication_status) = match response.response.clone() {\n                    Ok(unified_authentication_service::UasAuthenticationResponseData::PostAuthentication {\n                        authentication_details,\n                    }) => {\n                        (Some(\n                            hyperswitch_domain_models::payment_method_data::NetworkTokenData {\n                                token_number: authentication_details.token_details.payment_token,\n                                token_exp_month: authentication_details\n                                    .token_details\n                                    .token_expiration_month,\n                                token_exp_year: authentication_details\n                                    .token_details\n                                    .token_expiration_year,\n                                token_cryptogram: authentication_details\n                                    .dynamic_data_details\n                                    .and_then(|data| data.dynamic_data_value),\n                                card_issuer: None,\n                                card_network: None,\n                                card_type: None,\n                                card_issuing_country: None,\n                                bank_code: None,\n                                nick_name: None,\n                                eci: authentication_details.eci,\n                            }),common_enums::AuthenticationStatus::Success)\n                    },\n                    Ok(unified_authentication_service::UasAuthenticationResponseData::PreAuthentication {}) => (None, common_enums::AuthenticationStatus::Started),\n                    Err(_) => (None, common_enums::AuthenticationStatus::Failed)\n                };\n\n                payment_data.payment_attempt.payment_method =\n                    Some(common_enums::PaymentMethod::Card);\n\n                payment_data.payment_method_data = network_token\n                    .clone()\n                    .map(domain::PaymentMethodData::NetworkToken);\n\n                uas_utils::create_new_authentication(\n                    state,\n                    payment_data.payment_attempt.merchant_id.clone(),\n                    connector_mca.connector_name.to_string(),\n                    business_profile.get_id().clone(),\n                    Some(payment_data.payment_intent.get_id().clone()),\n                    click_to_pay_mca_id.to_owned(),\n                    &authentication_id,\n                    payment_data.service_details.clone(),\n                    authentication_status,\n                )\n                .await?;\n            }\n        }\n        logger::info!(\"skipping unified authentication service call since payment conditions {:?}, {:?} are not satisfied\", payment_data.payment_attempt.payment_method, business_profile.is_click_to_pay_enabled);\n        Ok(())\n    }",
+      "diff_span": {
+        "before": "        business_profile: &domain::Profile,\n        key_store: &domain::MerchantKeyStore,\n        authentication_product_ids: &common_types::payments::AuthenticationConnectorAccountMap,\n    ) -> CustomResult<(), errors::ApiErrorResponse> {\n        if let Some(payment_method) = payment_data.payment_attempt.payment_method {",
+        "after": "        key_store: &domain::MerchantKeyStore,\n    ) -> CustomResult<(), errors::ApiErrorResponse> {\n        let authentication_product_ids = business_profile\n            .authentication_product_ids\n            .clone()\n            .ok_or(errors::ApiErrorResponse::PreconditionFailed {\n                message: \"authentication_product_ids is not configured in business profile\"\n                    .to_string(),\n            })?;\n\n        if let Some(payment_method) = payment_data.payment_attempt.payment_method {\n            if payment_method == storage_enums::PaymentMethod::Card"
+      },
+      "commit_sha": "2e791d5289a5eaf011722af0413bc64967acca19"
+    },
+    {
+      "id": "crates/common_types/src/payments.rs::AuthenticationConnectorAccountMap::function::get_click_to_pay_connector_account_id",
+      "file": "crates/common_types/src/payments.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub fn get_click_to_pay_connector_account_id(\n        &self,\n    ) -> Result<common_utils::id_type::MerchantConnectorAccountId, errors::ValidationError> {\n        self.inner()\n            .get(&enums::AuthenticationProduct::ClickToPay)\n            .ok_or(errors::ValidationError::MissingRequiredField {\n                field_name: \"authentication_product_id\".to_string(),\n            })\n            .cloned()\n    }",
+      "after_code": "pub fn get_click_to_pay_connector_account_id(\n        &self,\n    ) -> Result<common_utils::id_type::MerchantConnectorAccountId, errors::ValidationError> {\n        self.0\n            .get(&enums::AuthenticationProduct::ClickToPay)\n            .ok_or(errors::ValidationError::MissingRequiredField {\n                field_name: \"authentication_product_id.click_to_pay\".to_string(),\n            })\n            .cloned()\n    }",
+      "diff_span": {
+        "before": "        &self,\n    ) -> Result<common_utils::id_type::MerchantConnectorAccountId, errors::ValidationError> {\n        self.inner()\n            .get(&enums::AuthenticationProduct::ClickToPay)\n            .ok_or(errors::ValidationError::MissingRequiredField {\n                field_name: \"authentication_product_id\".to_string(),\n            })\n            .cloned()",
+        "after": "        &self,\n    ) -> Result<common_utils::id_type::MerchantConnectorAccountId, errors::ValidationError> {\n        self.0\n            .get(&enums::AuthenticationProduct::ClickToPay)\n            .ok_or(errors::ValidationError::MissingRequiredField {\n                field_name: \"authentication_product_id.click_to_pay\".to_string(),\n            })\n            .cloned()"
+      },
+      "commit_sha": "2e791d5289a5eaf011722af0413bc64967acca19"
+    },
+    {
+      "id": "crates/common_types/src/payments.rs::impl::AuthenticationConnectorAccountMap",
+      "file": "crates/common_types/src/payments.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": true,
+      "before_code": "impl AuthenticationConnectorAccountMap {\n    /// get inner hashmap\n    pub fn inner(\n        &self,\n    ) -> &HashMap<enums::AuthenticationProduct, common_utils::id_type::MerchantConnectorAccountId>\n    {\n        &self.0\n    }\n    /// fn to get click to pay connector_account_id\n    pub fn get_click_to_pay_connector_account_id(\n        &self,\n    ) -> Result<common_utils::id_type::MerchantConnectorAccountId, errors::ValidationError> {\n        self.inner()\n            .get(&enums::AuthenticationProduct::ClickToPay)\n            .ok_or(errors::ValidationError::MissingRequiredField {\n                field_name: \"authentication_product_id\".to_string(),\n            })\n            .cloned()\n    }\n}",
+      "after_code": "impl AuthenticationConnectorAccountMap {\n    /// fn to get click to pay connector_account_id\n    pub fn get_click_to_pay_connector_account_id(\n        &self,\n    ) -> Result<common_utils::id_type::MerchantConnectorAccountId, errors::ValidationError> {\n        self.0\n            .get(&enums::AuthenticationProduct::ClickToPay)\n            .ok_or(errors::ValidationError::MissingRequiredField {\n                field_name: \"authentication_product_id.click_to_pay\".to_string(),\n            })\n            .cloned()\n    }\n}",
+      "diff_span": {
+        "before": "impl AuthenticationConnectorAccountMap {\n    /// get inner hashmap\n    pub fn inner(\n        &self,\n    ) -> &HashMap<enums::AuthenticationProduct, common_utils::id_type::MerchantConnectorAccountId>\n    {\n        &self.0\n    }\n    /// fn to get click to pay connector_account_id\n    pub fn get_click_to_pay_connector_account_id(\n        &self,\n    ) -> Result<common_utils::id_type::MerchantConnectorAccountId, errors::ValidationError> {\n        self.inner()\n            .get(&enums::AuthenticationProduct::ClickToPay)\n            .ok_or(errors::ValidationError::MissingRequiredField {\n                field_name: \"authentication_product_id\".to_string(),\n            })\n            .cloned()",
+        "after": "        &self,\n    ) -> Result<common_utils::id_type::MerchantConnectorAccountId, errors::ValidationError> {\n        self.0\n            .get(&enums::AuthenticationProduct::ClickToPay)\n            .ok_or(errors::ValidationError::MissingRequiredField {\n                field_name: \"authentication_product_id.click_to_pay\".to_string(),\n            })\n            .cloned()"
+      },
+      "commit_sha": "2e791d5289a5eaf011722af0413bc64967acca19",
+      "before_imports": [
+        "use common_enums::enums;",
+        "use std::collections::HashMap;"
+      ],
+      "after_imports": [
+        "use common_enums::enums;"
+      ]
+    },
+    {
+      "id": "crates/common_types/src/payments.rs::AuthenticationConnectorAccountMap::function::inner",
+      "file": "crates/common_types/src/payments.rs",
+      "kind": "function_item",
+      "status": "removed",
+      "before_code": "pub fn inner(\n        &self,\n    ) -> &HashMap<enums::AuthenticationProduct, common_utils::id_type::MerchantConnectorAccountId>\n    {\n        &self.0\n    }",
+      "after_code": null,
+      "diff_span": null,
+      "commit_sha": "2e791d5289a5eaf011722af0413bc64967acca19"
+    }
+  ]
+}

diffs/pr_6859/389ae52/diff.json

@@ -0,0 +1,6 @@
+{
+  "commit_sha": "389ae521c73dd728d527fba01e08bd44ddc9b799",
+  "pr_number": 6859,
+  "rust_files": [],
+  "diffs": []
+}

diffs/pr_6859/392c044/diff.json

@@ -0,0 +1,8 @@
+{
+  "commit_sha": "392c044f45744fb6b170f0b8be2f80fe0d262814",
+  "pr_number": 6859,
+  "rust_files": [
+    "crates/common_enums/src/enums.rs"
+  ],
+  "diffs": []
+}

diffs/pr_6859/3cfac70/diff.json

@@ -0,0 +1,24 @@
+{
+  "commit_sha": "3cfac70e273066165aaa72cfaaed301c815bfded",
+  "pr_number": 6859,
+  "rust_files": [
+    "crates/router/src/core/payments/helpers.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/router/src/core/payments/helpers.rs::function::is_merchant_eligible_authentication_service",
+      "file": "crates/router/src/core/payments/helpers.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn is_merchant_eligible_authentication_service(\n    merchant_id: &id_type::MerchantId,\n    state: &SessionState,\n) -> RouterResult<bool> {\n    let merchants_eligible_for_authentication_service = state\n        .store\n        .as_ref()\n        .find_config_by_key_unwrap_or(\n            consts::AUTHENTICATION_SERVICE_ELIGIBLE_CONFIG,\n            Some(\"[]\".to_string()),\n        )\n        .await;\n\n    let auth_eligible_array: Vec<String> = match merchants_eligible_for_authentication_service {\n        Ok(config) => serde_json::from_str(&config.config)\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"unable to parse authentication service config\")?,\n        Err(err) => {\n            if !err.current_context().is_db_not_found() {\n                logger::error!(\n                    \"Error fetching authentication service enabled merchant config {:?}\",\n                    err\n                );\n            }\n            Vec::new()\n        }\n    };\n\n    Ok(auth_eligible_array.contains(&merchant_id.get_string_repr().to_owned()))\n}",
+      "after_code": "pub async fn is_merchant_eligible_authentication_service(\n    merchant_id: &id_type::MerchantId,\n    state: &SessionState,\n) -> RouterResult<bool> {\n    let merchants_eligible_for_authentication_service = state\n        .store\n        .as_ref()\n        .find_config_by_key_unwrap_or(\n            consts::AUTHENTICATION_SERVICE_ELIGIBLE_CONFIG,\n            Some(\"[]\".to_string()),\n        )\n        .await;\n\n    let auth_eligible_array: Vec<String> = match merchants_eligible_for_authentication_service {\n        Ok(config) => serde_json::from_str(&config.config)\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"unable to parse authentication service config\")?,\n        Err(err) => {\n            logger::error!(\n                \"Error fetching authentication service enabled merchant config {:?}\",\n                err\n            );\n            Vec::new()\n        }\n    };\n\n    Ok(auth_eligible_array.contains(&merchant_id.get_string_repr().to_owned()))\n}",
+      "diff_span": {
+        "before": "            .attach_printable(\"unable to parse authentication service config\")?,\n        Err(err) => {\n            if !err.current_context().is_db_not_found() {\n                logger::error!(\n                    \"Error fetching authentication service enabled merchant config {:?}\",\n                    err\n                );\n            }\n            Vec::new()\n        }",
+        "after": "            .attach_printable(\"unable to parse authentication service config\")?,\n        Err(err) => {\n            logger::error!(\n                \"Error fetching authentication service enabled merchant config {:?}\",\n                err\n            );\n            Vec::new()\n        }"
+      },
+      "commit_sha": "3cfac70e273066165aaa72cfaaed301c815bfded"
+    }
+  ]
+}

diffs/pr_6859/4f82382/diff.json

@@ -0,0 +1,6 @@
+{
+  "commit_sha": "4f82382f08cd133fdf497069f05a8772c845a634",
+  "pr_number": 6859,
+  "rust_files": [],
+  "diffs": []
+}

diffs/pr_6859/5128445/diff.json

@@ -0,0 +1,6 @@
+{
+  "commit_sha": "5128445e5038534b8c6b10ea4ee7f868b5009e62",
+  "pr_number": 6859,
+  "rust_files": [],
+  "diffs": []
+}

diffs/pr_6859/5b1cd69/diff.json

@@ -0,0 +1,6 @@
+{
+  "commit_sha": "5b1cd69b172ab41eaceb8bfb4a38df4af3c59bb6",
+  "pr_number": 6859,
+  "rust_files": [],
+  "diffs": []
+}

diffs/pr_6859/5b4178b/diff.json

@@ -0,0 +1,6 @@
+{
+  "commit_sha": "5b4178b4b6f424e37421b8d8a8085f514b39a6b3",
+  "pr_number": 6859,
+  "rust_files": [],
+  "diffs": []
+}

diffs/pr_6859/5d0d9d1/diff.json

@@ -0,0 +1,25 @@
+{
+  "commit_sha": "5d0d9d178fd01752c501e41b195e3181d18423f2",
+  "pr_number": 6859,
+  "rust_files": [
+    "crates/hyperswitch_domain_models/src/merchant_connector_account.rs",
+    "crates/router/src/core/unified_authentication_service/utils.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/router/src/core/unified_authentication_service/utils.rs::function::construct_uas_router_data",
+      "file": "crates/router/src/core/unified_authentication_service/utils.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub fn construct_uas_router_data<F: Clone, Req, Res>(\n    authentication_connector_name: String,\n    payment_method: PaymentMethod,\n    merchant_id: common_utils::id_type::MerchantId,\n    address: Option<PaymentAddress>,\n    request_data: Req,\n    merchant_connector_account: &MerchantConnectorAccount,\n    authentication_id: Option<String>,\n) -> RouterResult<RouterData<F, Req, Res>> {\n    let test_mode: Option<bool> = merchant_connector_account.test_mode;\n    let auth_type: ConnectorAuthType = merchant_connector_account\n        .get_connector_account_details()\n        .parse_value(\"ConnectorAuthType\")\n        .change_context(ApiErrorResponse::InternalServerError)?;\n    Ok(RouterData {\n        flow: PhantomData,\n        merchant_id,\n        customer_id: None,\n        connector_customer: None,\n        connector: authentication_connector_name,\n        payment_id: common_utils::id_type::PaymentId::get_irrelevant_id(\"authentication\")\n            .get_string_repr()\n            .to_owned(),\n        attempt_id: IRRELEVANT_ATTEMPT_ID_IN_AUTHENTICATION_FLOW.to_owned(),\n        status: common_enums::AttemptStatus::default(),\n        payment_method,\n        connector_auth_type: auth_type,\n        description: None,\n        return_url: None,\n        address: address.unwrap_or_default(),\n        auth_type: common_enums::AuthenticationType::default(),\n        connector_meta_data: merchant_connector_account.metadata.clone(),\n        connector_wallets_details: merchant_connector_account.get_connector_wallets_details(),\n        amount_captured: None,\n        minor_amount_captured: None,\n        access_token: None,\n        session_token: None,\n        reference_id: None,\n        payment_method_token: None,\n        recurring_mandate_payment_data: None,\n        preprocessing_id: None,\n        payment_method_balance: None,\n        connector_api_version: None,\n        request: request_data,\n        response: Err(ErrorResponse::default()),\n        connector_request_reference_id:\n            IRRELEVANT_CONNECTOR_REQUEST_REFERENCE_ID_IN_AUTHENTICATION_FLOW.to_owned(),\n        #[cfg(feature = \"payouts\")]\n        payout_method_data: None,\n        #[cfg(feature = \"payouts\")]\n        quote_id: None,\n        test_mode,\n        connector_http_status_code: None,\n        external_latency: None,\n        apple_pay_flow: None,\n        frm_metadata: None,\n        dispute_id: None,\n        refund_id: None,\n        payment_method_status: None,\n        connector_response: None,\n        integrity_check: Ok(()),\n        additional_merchant_data: None,\n        header_payload: None,\n        connector_mandate_request_reference_id: None,\n        authentication_id,\n        psd2_sca_exemption_type: None,\n    })\n}",
+      "after_code": "pub fn construct_uas_router_data<F: Clone, Req, Res>(\n    authentication_connector_name: String,\n    payment_method: PaymentMethod,\n    merchant_id: common_utils::id_type::MerchantId,\n    address: Option<PaymentAddress>,\n    request_data: Req,\n    merchant_connector_account: &MerchantConnectorAccount,\n    authentication_id: Option<String>,\n) -> RouterResult<RouterData<F, Req, Res>> {\n    let auth_type: ConnectorAuthType = merchant_connector_account\n        .get_connector_account_details()\n        .parse_value(\"ConnectorAuthType\")\n        .change_context(ApiErrorResponse::InternalServerError)?;\n    Ok(RouterData {\n        flow: PhantomData,\n        merchant_id,\n        customer_id: None,\n        connector_customer: None,\n        connector: authentication_connector_name,\n        payment_id: common_utils::id_type::PaymentId::get_irrelevant_id(\"authentication\")\n            .get_string_repr()\n            .to_owned(),\n        attempt_id: IRRELEVANT_ATTEMPT_ID_IN_AUTHENTICATION_FLOW.to_owned(),\n        status: common_enums::AttemptStatus::default(),\n        payment_method,\n        connector_auth_type: auth_type,\n        description: None,\n        return_url: None,\n        address: address.unwrap_or_default(),\n        auth_type: common_enums::AuthenticationType::default(),\n        connector_meta_data: merchant_connector_account.metadata.clone(),\n        connector_wallets_details: merchant_connector_account.get_connector_wallets_details(),\n        amount_captured: None,\n        minor_amount_captured: None,\n        access_token: None,\n        session_token: None,\n        reference_id: None,\n        payment_method_token: None,\n        recurring_mandate_payment_data: None,\n        preprocessing_id: None,\n        payment_method_balance: None,\n        connector_api_version: None,\n        request: request_data,\n        response: Err(ErrorResponse::default()),\n        connector_request_reference_id:\n            IRRELEVANT_CONNECTOR_REQUEST_REFERENCE_ID_IN_AUTHENTICATION_FLOW.to_owned(),\n        #[cfg(feature = \"payouts\")]\n        payout_method_data: None,\n        #[cfg(feature = \"payouts\")]\n        quote_id: None,\n        test_mode: None,\n        connector_http_status_code: None,\n        external_latency: None,\n        apple_pay_flow: None,\n        frm_metadata: None,\n        dispute_id: None,\n        refund_id: None,\n        payment_method_status: None,\n        connector_response: None,\n        integrity_check: Ok(()),\n        additional_merchant_data: None,\n        header_payload: None,\n        connector_mandate_request_reference_id: None,\n        authentication_id,\n        psd2_sca_exemption_type: None,\n    })\n}",
+      "diff_span": {
+        "before": "    authentication_id: Option<String>,\n) -> RouterResult<RouterData<F, Req, Res>> {\n    let test_mode: Option<bool> = merchant_connector_account.test_mode;\n    let auth_type: ConnectorAuthType = merchant_connector_account\n        .get_connector_account_details()\n        .parse_value(\"ConnectorAuthType\")\n        .change_context(ApiErrorResponse::InternalServerError)?;\n    Ok(RouterData {\n        flow: PhantomData,\n        merchant_id,\n        customer_id: None,\n        connector_customer: None,\n        connector: authentication_connector_name,\n        payment_id: common_utils::id_type::PaymentId::get_irrelevant_id(\"authentication\")\n            .get_string_repr()\n            .to_owned(),\n        attempt_id: IRRELEVANT_ATTEMPT_ID_IN_AUTHENTICATION_FLOW.to_owned(),\n        status: common_enums::AttemptStatus::default(),\n        payment_method,\n        connector_auth_type: auth_type,\n        description: None,\n        return_url: None,\n        address: address.unwrap_or_default(),\n        auth_type: common_enums::AuthenticationType::default(),\n        connector_meta_data: merchant_connector_account.metadata.clone(),\n        connector_wallets_details: merchant_connector_account.get_connector_wallets_details(),\n        amount_captured: None,\n        minor_amount_captured: None,\n        access_token: None,\n        session_token: None,\n        reference_id: None,\n        payment_method_token: None,\n        recurring_mandate_payment_data: None,\n        preprocessing_id: None,\n        payment_method_balance: None,\n        connector_api_version: None,\n        request: request_data,\n        response: Err(ErrorResponse::default()),\n        connector_request_reference_id:\n            IRRELEVANT_CONNECTOR_REQUEST_REFERENCE_ID_IN_AUTHENTICATION_FLOW.to_owned(),\n        #[cfg(feature = \"payouts\")]\n        payout_method_data: None,\n        #[cfg(feature = \"payouts\")]\n        quote_id: None,\n        test_mode,\n        connector_http_status_code: None,\n        external_latency: None,",
+        "after": "        #[cfg(feature = \"payouts\")]\n        quote_id: None,\n        test_mode: None,\n        connector_http_status_code: None,\n        external_latency: None,"
+      },
+      "commit_sha": "5d0d9d178fd01752c501e41b195e3181d18423f2"
+    }
+  ]
+}

diffs/pr_6859/60a60e1/diff.json

@@ -0,0 +1,8 @@
+{
+  "commit_sha": "60a60e1d916e45a8acdd8c55345c7a51d4d0f504",
+  "pr_number": 6859,
+  "rust_files": [
+    "crates/hyperswitch_connectors/src/connectors/unified_authentication_service.rs"
+  ],
+  "diffs": []
+}

diffs/pr_6859/6e4bc87/diff.json

@@ -0,0 +1,8 @@
+{
+  "commit_sha": "6e4bc873d876cc83b2760a388ad62f854eb869ed",
+  "pr_number": 6859,
+  "rust_files": [
+    "crates/hyperswitch_domain_models/src/merchant_connector_account.rs"
+  ],
+  "diffs": []
+}

diffs/pr_6859/98b5af4/diff.json

@@ -0,0 +1,24 @@
+{
+  "commit_sha": "98b5af4ea8c7c5b79a37b61a88eae1463397e6ff",
+  "pr_number": 6859,
+  "rust_files": [
+    "crates/router/src/core/payments.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/router/src/core/payments.rs::function::payments_operation_core",
+      "file": "crates/router/src/core/payments.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn payments_operation_core<F, Req, Op, FData, D>(\n    state: &SessionState,\n    req_state: ReqState,\n    merchant_account: domain::MerchantAccount,\n    profile_id_from_auth_layer: Option<id_type::ProfileId>,\n    key_store: domain::MerchantKeyStore,\n    operation: Op,\n    req: Req,\n    call_connector_action: CallConnectorAction,\n    auth_flow: services::AuthFlow,\n    eligible_connectors: Option<Vec<common_enums::RoutableConnectors>>,\n    header_payload: HeaderPayload,\n) -> RouterResult<(D, Req, Option<domain::Customer>, Option<u16>, Option<u128>)>\nwhere\n    F: Send + Clone + Sync,\n    Req: Authenticate + Clone,\n    Op: Operation<F, Req, Data = D> + Send + Sync,\n    D: OperationSessionGetters<F> + OperationSessionSetters<F> + Send + Sync + Clone,\n\n    // To create connector flow specific interface data\n    D: ConstructFlowSpecificData<F, FData, router_types::PaymentsResponseData>,\n    RouterData<F, FData, router_types::PaymentsResponseData>: Feature<F, FData>,\n\n    // To construct connector flow specific api\n    dyn api::Connector:\n        services::api::ConnectorIntegration<F, FData, router_types::PaymentsResponseData>,\n\n    // To perform router related operation for PaymentResponse\n    PaymentResponse: Operation<F, FData, Data = D>,\n    FData: Send + Sync + Clone,\n{\n    let operation: BoxedOperation<'_, F, Req, D> = Box::new(operation);\n\n    tracing::Span::current().record(\"merchant_id\", merchant_account.get_id().get_string_repr());\n    let (operation, validate_result) = operation\n        .to_validate_request()?\n        .validate_request(&req, &merchant_account)?;\n\n    tracing::Span::current().record(\"payment_id\", format!(\"{}\", validate_result.payment_id));\n    // get profile from headers\n    let operations::GetTrackerResponse {\n        operation,\n        customer_details,\n        mut payment_data,\n        business_profile,\n        mandate_type,\n    } = operation\n        .to_get_tracker()?\n        .get_trackers(\n            state,\n            &validate_result.payment_id,\n            &req,\n            &merchant_account,\n            &key_store,\n            auth_flow,\n            &header_payload,\n        )\n        .await?;\n    core_utils::validate_profile_id_from_auth_layer(\n        profile_id_from_auth_layer,\n        &payment_data.get_payment_intent().clone(),\n    )?;\n\n    let (operation, customer) = operation\n        .to_domain()?\n        // get_customer_details\n        .get_or_create_customer_details(\n            state,\n            &mut payment_data,\n            customer_details,\n            &key_store,\n            merchant_account.storage_scheme,\n        )\n        .await\n        .to_not_found_response(errors::ApiErrorResponse::CustomerNotFound)\n        .attach_printable(\"Failed while fetching/creating customer\")?;\n\n    let authentication_type =\n        call_decision_manager(state, &merchant_account, &business_profile, &payment_data).await?;\n\n    payment_data.set_authentication_type_in_attempt(authentication_type);\n\n    let connector = get_connector_choice(\n        &operation,\n        state,\n        &req,\n        &merchant_account,\n        &business_profile,\n        &key_store,\n        &mut payment_data,\n        eligible_connectors,\n        mandate_type,\n    )\n    .await?;\n\n    let should_add_task_to_process_tracker = should_add_task_to_process_tracker(&payment_data);\n\n    let locale = header_payload.locale.clone();\n\n    payment_data = tokenize_in_router_when_confirm_false_or_external_authentication(\n        state,\n        &operation,\n        &mut payment_data,\n        &validate_result,\n        &key_store,\n        &customer,\n        &business_profile,\n    )\n    .await?;\n\n    let mut connector_http_status_code = None;\n    let mut external_latency = None;\n    if let Some(connector_details) = connector {\n        // Fetch and check FRM configs\n        #[cfg(feature = \"frm\")]\n        let mut frm_info = None;\n        #[allow(unused_variables, unused_mut)]\n        let mut should_continue_transaction: bool = true;\n        #[cfg(feature = \"frm\")]\n        let mut should_continue_capture: bool = true;\n        #[cfg(feature = \"frm\")]\n        let frm_configs = if state.conf.frm.enabled {\n            Box::pin(frm_core::call_frm_before_connector_call(\n                &operation,\n                &merchant_account,\n                &mut payment_data,\n                state,\n                &mut frm_info,\n                &customer,\n                &mut should_continue_transaction,\n                &mut should_continue_capture,\n                key_store.clone(),\n            ))\n            .await?\n        } else {\n            None\n        };\n        #[cfg(feature = \"frm\")]\n        logger::debug!(\n            \"frm_configs: {:?}\\nshould_continue_transaction: {:?}\\nshould_continue_capture: {:?}\",\n            frm_configs,\n            should_continue_transaction,\n            should_continue_capture,\n        );\n\n        operation\n            .to_domain()?\n            .call_external_three_ds_authentication_if_eligible(\n                state,\n                &mut payment_data,\n                &mut should_continue_transaction,\n                &connector_details,\n                &business_profile,\n                &key_store,\n                mandate_type,\n            )\n            .await?;\n\n        let merchants_eligible_for_authentication_service = state\n            .store\n            .as_ref()\n            .find_config_by_key(crate::consts::AUTHENTICATION_SERVICE_ELIGIBLE_CONFIG)\n            .await\n            .to_not_found_response(errors::ApiErrorResponse::ConfigNotFound)?;\n        let auth_eligible_array: Vec<String> =\n            serde_json::from_str(&merchants_eligible_for_authentication_service.config)\n                .change_context(errors::ApiErrorResponse::InternalServerError)\n                .attach_printable(\"unable to parse authentication service config\")?;\n        let merchant_id = merchant_account.get_id();\n\n        if auth_eligible_array.contains(&merchant_id.get_string_repr().to_owned()) {\n            let authentication_product_ids = business_profile\n                .authentication_product_ids\n                .clone()\n                .ok_or(errors::ApiErrorResponse::PreconditionFailed {\n                    message: \"authentication_product_ids is not configured in business profile\"\n                        .to_string(),\n                })?;\n            operation\n                .to_domain()?\n                .call_unified_authentication_service_if_eligible(\n                    state,\n                    &mut payment_data,\n                    &mut should_continue_transaction,\n                    &connector_details,\n                    &business_profile,\n                    &key_store,\n                    &authentication_product_ids,\n                )\n                .await?;\n        } else {\n            logger::info!(\n                \"skipping authentication service call since the merchant is not eligible.\"\n            )\n        };\n\n        operation\n            .to_domain()?\n            .payments_dynamic_tax_calculation(\n                state,\n                &mut payment_data,\n                &connector_details,\n                &business_profile,\n                &key_store,\n                &merchant_account,\n            )\n            .await?;\n\n        if should_continue_transaction {\n            #[cfg(feature = \"frm\")]\n            match (\n                should_continue_capture,\n                payment_data.get_payment_attempt().capture_method,\n            ) {\n                (\n                    false,\n                    Some(storage_enums::CaptureMethod::Automatic)\n                    | Some(storage_enums::CaptureMethod::SequentialAutomatic),\n                )\n                | (false, Some(storage_enums::CaptureMethod::Scheduled)) => {\n                    if let Some(info) = &mut frm_info {\n                        if let Some(frm_data) = &mut info.frm_data {\n                            frm_data.fraud_check.payment_capture_method =\n                                payment_data.get_payment_attempt().capture_method;\n                        }\n                    }\n                    payment_data\n                        .set_capture_method_in_attempt(storage_enums::CaptureMethod::Manual);\n                    logger::debug!(\"payment_id : {:?} capture method has been changed to manual, since it has configured Post FRM flow\",payment_data.get_payment_attempt().payment_id);\n                }\n                _ => (),\n            };\n            payment_data = match connector_details {\n                ConnectorCallType::PreDetermined(connector) => {\n                    #[cfg(all(feature = \"dynamic_routing\", feature = \"v1\"))]\n                    let routable_connectors =\n                        convert_connector_data_to_routable_connectors(&[connector.clone()])\n                            .map_err(|e| logger::error!(routable_connector_error=?e))\n                            .unwrap_or_default();\n                    let schedule_time = if should_add_task_to_process_tracker {\n                        payment_sync::get_sync_process_schedule_time(\n                            &*state.store,\n                            connector.connector.id(),\n                            merchant_account.get_id(),\n                            0,\n                        )\n                        .await\n                        .change_context(errors::ApiErrorResponse::InternalServerError)\n                        .attach_printable(\"Failed while getting process schedule time\")?\n                    } else {\n                        None\n                    };\n                    let (router_data, mca) = call_connector_service(\n                        state,\n                        req_state.clone(),\n                        &merchant_account,\n                        &key_store,\n                        connector.clone(),\n                        &operation,\n                        &mut payment_data,\n                        &customer,\n                        call_connector_action.clone(),\n                        &validate_result,\n                        schedule_time,\n                        header_payload.clone(),\n                        #[cfg(feature = \"frm\")]\n                        frm_info.as_ref().and_then(|fi| fi.suggested_action),\n                        #[cfg(not(feature = \"frm\"))]\n                        None,\n                        &business_profile,\n                        false,\n                    )\n                    .await?;\n\n                    let op_ref = &operation;\n                    let should_trigger_post_processing_flows = is_operation_confirm(&operation);\n\n                    let operation = Box::new(PaymentResponse);\n\n                    connector_http_status_code = router_data.connector_http_status_code;\n                    external_latency = router_data.external_latency;\n                    //add connector http status code metrics\n                    add_connector_http_status_code_metrics(connector_http_status_code);\n\n                    operation\n                        .to_post_update_tracker()?\n                        .save_pm_and_mandate(\n                            state,\n                            &router_data,\n                            &merchant_account,\n                            &key_store,\n                            &mut payment_data,\n                            &business_profile,\n                        )\n                        .await?;\n\n                    let mut payment_data = operation\n                        .to_post_update_tracker()?\n                        .update_tracker(\n                            state,\n                            payment_data,\n                            router_data,\n                            &key_store,\n                            merchant_account.storage_scheme,\n                            &locale,\n                            #[cfg(all(feature = \"dynamic_routing\", feature = \"v1\"))]\n                            routable_connectors,\n                            #[cfg(all(feature = \"dynamic_routing\", feature = \"v1\"))]\n                            &business_profile,\n                        )\n                        .await?;\n\n                    if should_trigger_post_processing_flows {\n                        complete_postprocessing_steps_if_required(\n                            state,\n                            &merchant_account,\n                            &key_store,\n                            &customer,\n                            &mca,\n                            &connector,\n                            &mut payment_data,\n                            op_ref,\n                            Some(header_payload.clone()),\n                        )\n                        .await?;\n                    }\n\n                    payment_data\n                }\n\n                ConnectorCallType::Retryable(connectors) => {\n                    #[cfg(all(feature = \"dynamic_routing\", feature = \"v1\"))]\n                    let routable_connectors =\n                        convert_connector_data_to_routable_connectors(&connectors)\n                            .map_err(|e| logger::error!(routable_connector_error=?e))\n                            .unwrap_or_default();\n\n                    let mut connectors = connectors.into_iter();\n\n                    let connector_data = get_connector_data(&mut connectors)?;\n\n                    let schedule_time = if should_add_task_to_process_tracker {\n                        payment_sync::get_sync_process_schedule_time(\n                            &*state.store,\n                            connector_data.connector.id(),\n                            merchant_account.get_id(),\n                            0,\n                        )\n                        .await\n                        .change_context(errors::ApiErrorResponse::InternalServerError)\n                        .attach_printable(\"Failed while getting process schedule time\")?\n                    } else {\n                        None\n                    };\n                    let (router_data, mca) = call_connector_service(\n                        state,\n                        req_state.clone(),\n                        &merchant_account,\n                        &key_store,\n                        connector_data.clone(),\n                        &operation,\n                        &mut payment_data,\n                        &customer,\n                        call_connector_action.clone(),\n                        &validate_result,\n                        schedule_time,\n                        header_payload.clone(),\n                        #[cfg(feature = \"frm\")]\n                        frm_info.as_ref().and_then(|fi| fi.suggested_action),\n                        #[cfg(not(feature = \"frm\"))]\n                        None,\n                        &business_profile,\n                        false,\n                    )\n                    .await?;\n\n                    #[cfg(all(feature = \"retry\", feature = \"v1\"))]\n                    let mut router_data = router_data;\n                    #[cfg(all(feature = \"retry\", feature = \"v1\"))]\n                    {\n                        use crate::core::payments::retry::{self, GsmValidation};\n                        let config_bool = retry::config_should_call_gsm(\n                            &*state.store,\n                            merchant_account.get_id(),\n                            &business_profile,\n                        )\n                        .await;\n\n                        if config_bool && router_data.should_call_gsm() {\n                            router_data = retry::do_gsm_actions(\n                                state,\n                                req_state.clone(),\n                                &mut payment_data,\n                                connectors,\n                                connector_data.clone(),\n                                router_data,\n                                &merchant_account,\n                                &key_store,\n                                &operation,\n                                &customer,\n                                &validate_result,\n                                schedule_time,\n                                #[cfg(feature = \"frm\")]\n                                frm_info.as_ref().and_then(|fi| fi.suggested_action),\n                                #[cfg(not(feature = \"frm\"))]\n                                None,\n                                &business_profile,\n                            )\n                            .await?;\n                        };\n                    }\n\n                    let op_ref = &operation;\n                    let should_trigger_post_processing_flows = is_operation_confirm(&operation);\n\n                    let operation = Box::new(PaymentResponse);\n                    connector_http_status_code = router_data.connector_http_status_code;\n                    external_latency = router_data.external_latency;\n                    //add connector http status code metrics\n                    add_connector_http_status_code_metrics(connector_http_status_code);\n\n                    operation\n                        .to_post_update_tracker()?\n                        .save_pm_and_mandate(\n                            state,\n                            &router_data,\n                            &merchant_account,\n                            &key_store,\n                            &mut payment_data,\n                            &business_profile,\n                        )\n                        .await?;\n\n                    let mut payment_data = operation\n                        .to_post_update_tracker()?\n                        .update_tracker(\n                            state,\n                            payment_data,\n                            router_data,\n                            &key_store,\n                            merchant_account.storage_scheme,\n                            &locale,\n                            #[cfg(all(feature = \"dynamic_routing\", feature = \"v1\"))]\n                            routable_connectors,\n                            #[cfg(all(feature = \"dynamic_routing\", feature = \"v1\"))]\n                            &business_profile,\n                        )\n                        .await?;\n\n                    if should_trigger_post_processing_flows {\n                        complete_postprocessing_steps_if_required(\n                            state,\n                            &merchant_account,\n                            &key_store,\n                            &customer,\n                            &mca,\n                            &connector_data,\n                            &mut payment_data,\n                            op_ref,\n                            Some(header_payload.clone()),\n                        )\n                        .await?;\n                    }\n\n                    payment_data\n                }\n\n                ConnectorCallType::SessionMultiple(connectors) => {\n                    let session_surcharge_details =\n                        call_surcharge_decision_management_for_session_flow(\n                            state,\n                            &merchant_account,\n                            &business_profile,\n                            payment_data.get_payment_attempt(),\n                            payment_data.get_payment_intent(),\n                            payment_data.get_billing_address(),\n                            &connectors,\n                        )\n                        .await?;\n                    Box::pin(call_multiple_connectors_service(\n                        state,\n                        &merchant_account,\n                        &key_store,\n                        connectors,\n                        &operation,\n                        payment_data,\n                        &customer,\n                        session_surcharge_details,\n                        &business_profile,\n                        header_payload.clone(),\n                    ))\n                    .await?\n                }\n            };\n\n            #[cfg(feature = \"frm\")]\n            if let Some(fraud_info) = &mut frm_info {\n                #[cfg(feature = \"v1\")]\n                Box::pin(frm_core::post_payment_frm_core(\n                    state,\n                    req_state,\n                    &merchant_account,\n                    &mut payment_data,\n                    fraud_info,\n                    frm_configs\n                        .clone()\n                        .ok_or(errors::ApiErrorResponse::MissingRequiredField {\n                            field_name: \"frm_configs\",\n                        })\n                        .attach_printable(\"Frm configs label not found\")?,\n                    &customer,\n                    key_store.clone(),\n                    &mut should_continue_capture,\n                ))\n                .await?;\n            }\n        } else {\n            (_, payment_data) = operation\n                .to_update_tracker()?\n                .update_trackers(\n                    state,\n                    req_state,\n                    payment_data.clone(),\n                    customer.clone(),\n                    validate_result.storage_scheme,\n                    None,\n                    &key_store,\n                    #[cfg(feature = \"frm\")]\n                    frm_info.and_then(|info| info.suggested_action),\n                    #[cfg(not(feature = \"frm\"))]\n                    None,\n                    header_payload.clone(),\n                )\n                .await?;\n        }\n\n        let payment_intent_status = payment_data.get_payment_intent().status;\n\n        payment_data\n            .get_payment_attempt()\n            .payment_token\n            .as_ref()\n            .zip(payment_data.get_payment_attempt().payment_method)\n            .map(ParentPaymentMethodToken::create_key_for_token)\n            .async_map(|key_for_hyperswitch_token| async move {\n                if key_for_hyperswitch_token\n                    .should_delete_payment_method_token(payment_intent_status)\n                {\n                    let _ = key_for_hyperswitch_token.delete(state).await;\n                }\n            })\n            .await;\n    } else {\n        (_, payment_data) = operation\n            .to_update_tracker()?\n            .update_trackers(\n                state,\n                req_state,\n                payment_data.clone(),\n                customer.clone(),\n                validate_result.storage_scheme,\n                None,\n                &key_store,\n                None,\n                header_payload.clone(),\n            )\n            .await?;\n    }\n\n    let cloned_payment_data = payment_data.clone();\n    let cloned_customer = customer.clone();\n\n    #[cfg(feature = \"v1\")]\n    operation\n        .to_domain()?\n        .store_extended_card_info_temporarily(\n            state,\n            payment_data.get_payment_intent().get_id(),\n            &business_profile,\n            payment_data.get_payment_method_data(),\n        )\n        .await?;\n\n    utils::trigger_payments_webhook(\n        merchant_account,\n        business_profile,\n        &key_store,\n        cloned_payment_data,\n        cloned_customer,\n        state,\n        operation,\n    )\n    .await\n    .map_err(|error| logger::warn!(payments_outgoing_webhook_error=?error))\n    .ok();\n\n    Ok((\n        payment_data,\n        req,\n        customer,\n        connector_http_status_code,\n        external_latency,\n    ))\n}",
+      "after_code": "pub async fn payments_operation_core<F, Req, Op, FData, D>(\n    state: &SessionState,\n    req_state: ReqState,\n    merchant_account: domain::MerchantAccount,\n    profile_id_from_auth_layer: Option<id_type::ProfileId>,\n    key_store: domain::MerchantKeyStore,\n    operation: Op,\n    req: Req,\n    call_connector_action: CallConnectorAction,\n    auth_flow: services::AuthFlow,\n    eligible_connectors: Option<Vec<common_enums::RoutableConnectors>>,\n    header_payload: HeaderPayload,\n) -> RouterResult<(D, Req, Option<domain::Customer>, Option<u16>, Option<u128>)>\nwhere\n    F: Send + Clone + Sync,\n    Req: Authenticate + Clone,\n    Op: Operation<F, Req, Data = D> + Send + Sync,\n    D: OperationSessionGetters<F> + OperationSessionSetters<F> + Send + Sync + Clone,\n\n    // To create connector flow specific interface data\n    D: ConstructFlowSpecificData<F, FData, router_types::PaymentsResponseData>,\n    RouterData<F, FData, router_types::PaymentsResponseData>: Feature<F, FData>,\n\n    // To construct connector flow specific api\n    dyn api::Connector:\n        services::api::ConnectorIntegration<F, FData, router_types::PaymentsResponseData>,\n\n    // To perform router related operation for PaymentResponse\n    PaymentResponse: Operation<F, FData, Data = D>,\n    FData: Send + Sync + Clone,\n{\n    let operation: BoxedOperation<'_, F, Req, D> = Box::new(operation);\n\n    tracing::Span::current().record(\"merchant_id\", merchant_account.get_id().get_string_repr());\n    let (operation, validate_result) = operation\n        .to_validate_request()?\n        .validate_request(&req, &merchant_account)?;\n\n    tracing::Span::current().record(\"payment_id\", format!(\"{}\", validate_result.payment_id));\n    // get profile from headers\n    let operations::GetTrackerResponse {\n        operation,\n        customer_details,\n        mut payment_data,\n        business_profile,\n        mandate_type,\n    } = operation\n        .to_get_tracker()?\n        .get_trackers(\n            state,\n            &validate_result.payment_id,\n            &req,\n            &merchant_account,\n            &key_store,\n            auth_flow,\n            &header_payload,\n        )\n        .await?;\n    core_utils::validate_profile_id_from_auth_layer(\n        profile_id_from_auth_layer,\n        &payment_data.get_payment_intent().clone(),\n    )?;\n\n    let (operation, customer) = operation\n        .to_domain()?\n        // get_customer_details\n        .get_or_create_customer_details(\n            state,\n            &mut payment_data,\n            customer_details,\n            &key_store,\n            merchant_account.storage_scheme,\n        )\n        .await\n        .to_not_found_response(errors::ApiErrorResponse::CustomerNotFound)\n        .attach_printable(\"Failed while fetching/creating customer\")?;\n\n    let authentication_type =\n        call_decision_manager(state, &merchant_account, &business_profile, &payment_data).await?;\n\n    payment_data.set_authentication_type_in_attempt(authentication_type);\n\n    let connector = get_connector_choice(\n        &operation,\n        state,\n        &req,\n        &merchant_account,\n        &business_profile,\n        &key_store,\n        &mut payment_data,\n        eligible_connectors,\n        mandate_type,\n    )\n    .await?;\n\n    let should_add_task_to_process_tracker = should_add_task_to_process_tracker(&payment_data);\n\n    let locale = header_payload.locale.clone();\n\n    payment_data = tokenize_in_router_when_confirm_false_or_external_authentication(\n        state,\n        &operation,\n        &mut payment_data,\n        &validate_result,\n        &key_store,\n        &customer,\n        &business_profile,\n    )\n    .await?;\n\n    let mut connector_http_status_code = None;\n    let mut external_latency = None;\n    if let Some(connector_details) = connector {\n        // Fetch and check FRM configs\n        #[cfg(feature = \"frm\")]\n        let mut frm_info = None;\n        #[allow(unused_variables, unused_mut)]\n        let mut should_continue_transaction: bool = true;\n        #[cfg(feature = \"frm\")]\n        let mut should_continue_capture: bool = true;\n        #[cfg(feature = \"frm\")]\n        let frm_configs = if state.conf.frm.enabled {\n            Box::pin(frm_core::call_frm_before_connector_call(\n                &operation,\n                &merchant_account,\n                &mut payment_data,\n                state,\n                &mut frm_info,\n                &customer,\n                &mut should_continue_transaction,\n                &mut should_continue_capture,\n                key_store.clone(),\n            ))\n            .await?\n        } else {\n            None\n        };\n        #[cfg(feature = \"frm\")]\n        logger::debug!(\n            \"frm_configs: {:?}\\nshould_continue_transaction: {:?}\\nshould_continue_capture: {:?}\",\n            frm_configs,\n            should_continue_transaction,\n            should_continue_capture,\n        );\n\n        let merchants_eligible_for_authentication_service = state\n            .store\n            .as_ref()\n            .find_config_by_key(crate::consts::AUTHENTICATION_SERVICE_ELIGIBLE_CONFIG)\n            .await\n            .to_not_found_response(errors::ApiErrorResponse::ConfigNotFound)?;\n        let auth_eligible_array: Vec<String> =\n            serde_json::from_str(&merchants_eligible_for_authentication_service.config)\n                .change_context(errors::ApiErrorResponse::InternalServerError)\n                .attach_printable(\"unable to parse authentication service config\")?;\n        let merchant_id = merchant_account.get_id();\n\n        if auth_eligible_array.contains(&merchant_id.get_string_repr().to_owned()) {\n            let authentication_product_ids = business_profile\n                .authentication_product_ids\n                .clone()\n                .ok_or(errors::ApiErrorResponse::PreconditionFailed {\n                    message: \"authentication_product_ids is not configured in business profile\"\n                        .to_string(),\n                })?;\n            operation\n                .to_domain()?\n                .call_unified_authentication_service_if_eligible(\n                    state,\n                    &mut payment_data,\n                    &mut should_continue_transaction,\n                    &connector_details,\n                    &business_profile,\n                    &key_store,\n                    &authentication_product_ids,\n                )\n                .await?;\n        } else {\n            logger::info!(\n                \"skipping authentication service call since the merchant is not eligible.\"\n            );\n\n            operation\n                .to_domain()?\n                .call_external_three_ds_authentication_if_eligible(\n                    state,\n                    &mut payment_data,\n                    &mut should_continue_transaction,\n                    &connector_details,\n                    &business_profile,\n                    &key_store,\n                    mandate_type,\n                )\n                .await?;\n        };\n\n        operation\n            .to_domain()?\n            .payments_dynamic_tax_calculation(\n                state,\n                &mut payment_data,\n                &connector_details,\n                &business_profile,\n                &key_store,\n                &merchant_account,\n            )\n            .await?;\n\n        if should_continue_transaction {\n            #[cfg(feature = \"frm\")]\n            match (\n                should_continue_capture,\n                payment_data.get_payment_attempt().capture_method,\n            ) {\n                (\n                    false,\n                    Some(storage_enums::CaptureMethod::Automatic)\n                    | Some(storage_enums::CaptureMethod::SequentialAutomatic),\n                )\n                | (false, Some(storage_enums::CaptureMethod::Scheduled)) => {\n                    if let Some(info) = &mut frm_info {\n                        if let Some(frm_data) = &mut info.frm_data {\n                            frm_data.fraud_check.payment_capture_method =\n                                payment_data.get_payment_attempt().capture_method;\n                        }\n                    }\n                    payment_data\n                        .set_capture_method_in_attempt(storage_enums::CaptureMethod::Manual);\n                    logger::debug!(\"payment_id : {:?} capture method has been changed to manual, since it has configured Post FRM flow\",payment_data.get_payment_attempt().payment_id);\n                }\n                _ => (),\n            };\n            payment_data = match connector_details {\n                ConnectorCallType::PreDetermined(connector) => {\n                    #[cfg(all(feature = \"dynamic_routing\", feature = \"v1\"))]\n                    let routable_connectors =\n                        convert_connector_data_to_routable_connectors(&[connector.clone()])\n                            .map_err(|e| logger::error!(routable_connector_error=?e))\n                            .unwrap_or_default();\n                    let schedule_time = if should_add_task_to_process_tracker {\n                        payment_sync::get_sync_process_schedule_time(\n                            &*state.store,\n                            connector.connector.id(),\n                            merchant_account.get_id(),\n                            0,\n                        )\n                        .await\n                        .change_context(errors::ApiErrorResponse::InternalServerError)\n                        .attach_printable(\"Failed while getting process schedule time\")?\n                    } else {\n                        None\n                    };\n                    let (router_data, mca) = call_connector_service(\n                        state,\n                        req_state.clone(),\n                        &merchant_account,\n                        &key_store,\n                        connector.clone(),\n                        &operation,\n                        &mut payment_data,\n                        &customer,\n                        call_connector_action.clone(),\n                        &validate_result,\n                        schedule_time,\n                        header_payload.clone(),\n                        #[cfg(feature = \"frm\")]\n                        frm_info.as_ref().and_then(|fi| fi.suggested_action),\n                        #[cfg(not(feature = \"frm\"))]\n                        None,\n                        &business_profile,\n                        false,\n                    )\n                    .await?;\n\n                    let op_ref = &operation;\n                    let should_trigger_post_processing_flows = is_operation_confirm(&operation);\n\n                    let operation = Box::new(PaymentResponse);\n\n                    connector_http_status_code = router_data.connector_http_status_code;\n                    external_latency = router_data.external_latency;\n                    //add connector http status code metrics\n                    add_connector_http_status_code_metrics(connector_http_status_code);\n\n                    operation\n                        .to_post_update_tracker()?\n                        .save_pm_and_mandate(\n                            state,\n                            &router_data,\n                            &merchant_account,\n                            &key_store,\n                            &mut payment_data,\n                            &business_profile,\n                        )\n                        .await?;\n\n                    let mut payment_data = operation\n                        .to_post_update_tracker()?\n                        .update_tracker(\n                            state,\n                            payment_data,\n                            router_data,\n                            &key_store,\n                            merchant_account.storage_scheme,\n                            &locale,\n                            #[cfg(all(feature = \"dynamic_routing\", feature = \"v1\"))]\n                            routable_connectors,\n                            #[cfg(all(feature = \"dynamic_routing\", feature = \"v1\"))]\n                            &business_profile,\n                        )\n                        .await?;\n\n                    if should_trigger_post_processing_flows {\n                        complete_postprocessing_steps_if_required(\n                            state,\n                            &merchant_account,\n                            &key_store,\n                            &customer,\n                            &mca,\n                            &connector,\n                            &mut payment_data,\n                            op_ref,\n                            Some(header_payload.clone()),\n                        )\n                        .await?;\n                    }\n\n                    payment_data\n                }\n\n                ConnectorCallType::Retryable(connectors) => {\n                    #[cfg(all(feature = \"dynamic_routing\", feature = \"v1\"))]\n                    let routable_connectors =\n                        convert_connector_data_to_routable_connectors(&connectors)\n                            .map_err(|e| logger::error!(routable_connector_error=?e))\n                            .unwrap_or_default();\n\n                    let mut connectors = connectors.into_iter();\n\n                    let connector_data = get_connector_data(&mut connectors)?;\n\n                    let schedule_time = if should_add_task_to_process_tracker {\n                        payment_sync::get_sync_process_schedule_time(\n                            &*state.store,\n                            connector_data.connector.id(),\n                            merchant_account.get_id(),\n                            0,\n                        )\n                        .await\n                        .change_context(errors::ApiErrorResponse::InternalServerError)\n                        .attach_printable(\"Failed while getting process schedule time\")?\n                    } else {\n                        None\n                    };\n                    let (router_data, mca) = call_connector_service(\n                        state,\n                        req_state.clone(),\n                        &merchant_account,\n                        &key_store,\n                        connector_data.clone(),\n                        &operation,\n                        &mut payment_data,\n                        &customer,\n                        call_connector_action.clone(),\n                        &validate_result,\n                        schedule_time,\n                        header_payload.clone(),\n                        #[cfg(feature = \"frm\")]\n                        frm_info.as_ref().and_then(|fi| fi.suggested_action),\n                        #[cfg(not(feature = \"frm\"))]\n                        None,\n                        &business_profile,\n                        false,\n                    )\n                    .await?;\n\n                    #[cfg(all(feature = \"retry\", feature = \"v1\"))]\n                    let mut router_data = router_data;\n                    #[cfg(all(feature = \"retry\", feature = \"v1\"))]\n                    {\n                        use crate::core::payments::retry::{self, GsmValidation};\n                        let config_bool = retry::config_should_call_gsm(\n                            &*state.store,\n                            merchant_account.get_id(),\n                            &business_profile,\n                        )\n                        .await;\n\n                        if config_bool && router_data.should_call_gsm() {\n                            router_data = retry::do_gsm_actions(\n                                state,\n                                req_state.clone(),\n                                &mut payment_data,\n                                connectors,\n                                connector_data.clone(),\n                                router_data,\n                                &merchant_account,\n                                &key_store,\n                                &operation,\n                                &customer,\n                                &validate_result,\n                                schedule_time,\n                                #[cfg(feature = \"frm\")]\n                                frm_info.as_ref().and_then(|fi| fi.suggested_action),\n                                #[cfg(not(feature = \"frm\"))]\n                                None,\n                                &business_profile,\n                            )\n                            .await?;\n                        };\n                    }\n\n                    let op_ref = &operation;\n                    let should_trigger_post_processing_flows = is_operation_confirm(&operation);\n\n                    let operation = Box::new(PaymentResponse);\n                    connector_http_status_code = router_data.connector_http_status_code;\n                    external_latency = router_data.external_latency;\n                    //add connector http status code metrics\n                    add_connector_http_status_code_metrics(connector_http_status_code);\n\n                    operation\n                        .to_post_update_tracker()?\n                        .save_pm_and_mandate(\n                            state,\n                            &router_data,\n                            &merchant_account,\n                            &key_store,\n                            &mut payment_data,\n                            &business_profile,\n                        )\n                        .await?;\n\n                    let mut payment_data = operation\n                        .to_post_update_tracker()?\n                        .update_tracker(\n                            state,\n                            payment_data,\n                            router_data,\n                            &key_store,\n                            merchant_account.storage_scheme,\n                            &locale,\n                            #[cfg(all(feature = \"dynamic_routing\", feature = \"v1\"))]\n                            routable_connectors,\n                            #[cfg(all(feature = \"dynamic_routing\", feature = \"v1\"))]\n                            &business_profile,\n                        )\n                        .await?;\n\n                    if should_trigger_post_processing_flows {\n                        complete_postprocessing_steps_if_required(\n                            state,\n                            &merchant_account,\n                            &key_store,\n                            &customer,\n                            &mca,\n                            &connector_data,\n                            &mut payment_data,\n                            op_ref,\n                            Some(header_payload.clone()),\n                        )\n                        .await?;\n                    }\n\n                    payment_data\n                }\n\n                ConnectorCallType::SessionMultiple(connectors) => {\n                    let session_surcharge_details =\n                        call_surcharge_decision_management_for_session_flow(\n                            state,\n                            &merchant_account,\n                            &business_profile,\n                            payment_data.get_payment_attempt(),\n                            payment_data.get_payment_intent(),\n                            payment_data.get_billing_address(),\n                            &connectors,\n                        )\n                        .await?;\n                    Box::pin(call_multiple_connectors_service(\n                        state,\n                        &merchant_account,\n                        &key_store,\n                        connectors,\n                        &operation,\n                        payment_data,\n                        &customer,\n                        session_surcharge_details,\n                        &business_profile,\n                        header_payload.clone(),\n                    ))\n                    .await?\n                }\n            };\n\n            #[cfg(feature = \"frm\")]\n            if let Some(fraud_info) = &mut frm_info {\n                #[cfg(feature = \"v1\")]\n                Box::pin(frm_core::post_payment_frm_core(\n                    state,\n                    req_state,\n                    &merchant_account,\n                    &mut payment_data,\n                    fraud_info,\n                    frm_configs\n                        .clone()\n                        .ok_or(errors::ApiErrorResponse::MissingRequiredField {\n                            field_name: \"frm_configs\",\n                        })\n                        .attach_printable(\"Frm configs label not found\")?,\n                    &customer,\n                    key_store.clone(),\n                    &mut should_continue_capture,\n                ))\n                .await?;\n            }\n        } else {\n            (_, payment_data) = operation\n                .to_update_tracker()?\n                .update_trackers(\n                    state,\n                    req_state,\n                    payment_data.clone(),\n                    customer.clone(),\n                    validate_result.storage_scheme,\n                    None,\n                    &key_store,\n                    #[cfg(feature = \"frm\")]\n                    frm_info.and_then(|info| info.suggested_action),\n                    #[cfg(not(feature = \"frm\"))]\n                    None,\n                    header_payload.clone(),\n                )\n                .await?;\n        }\n\n        let payment_intent_status = payment_data.get_payment_intent().status;\n\n        payment_data\n            .get_payment_attempt()\n            .payment_token\n            .as_ref()\n            .zip(payment_data.get_payment_attempt().payment_method)\n            .map(ParentPaymentMethodToken::create_key_for_token)\n            .async_map(|key_for_hyperswitch_token| async move {\n                if key_for_hyperswitch_token\n                    .should_delete_payment_method_token(payment_intent_status)\n                {\n                    let _ = key_for_hyperswitch_token.delete(state).await;\n                }\n            })\n            .await;\n    } else {\n        (_, payment_data) = operation\n            .to_update_tracker()?\n            .update_trackers(\n                state,\n                req_state,\n                payment_data.clone(),\n                customer.clone(),\n                validate_result.storage_scheme,\n                None,\n                &key_store,\n                None,\n                header_payload.clone(),\n            )\n            .await?;\n    }\n\n    let cloned_payment_data = payment_data.clone();\n    let cloned_customer = customer.clone();\n\n    #[cfg(feature = \"v1\")]\n    operation\n        .to_domain()?\n        .store_extended_card_info_temporarily(\n            state,\n            payment_data.get_payment_intent().get_id(),\n            &business_profile,\n            payment_data.get_payment_method_data(),\n        )\n        .await?;\n\n    utils::trigger_payments_webhook(\n        merchant_account,\n        business_profile,\n        &key_store,\n        cloned_payment_data,\n        cloned_customer,\n        state,\n        operation,\n    )\n    .await\n    .map_err(|error| logger::warn!(payments_outgoing_webhook_error=?error))\n    .ok();\n\n    Ok((\n        payment_data,\n        req,\n        customer,\n        connector_http_status_code,\n        external_latency,\n    ))\n}",
+      "diff_span": {
+        "before": "        );\n\n        operation\n            .to_domain()?\n            .call_external_three_ds_authentication_if_eligible(\n                state,\n                &mut payment_data,\n                &mut should_continue_transaction,\n                &connector_details,\n                &business_profile,\n                &key_store,\n                mandate_type,\n            )\n            .await?;\n\n        let merchants_eligible_for_authentication_service = state\n            .store\n            .as_ref()\n            .find_config_by_key(crate::consts::AUTHENTICATION_SERVICE_ELIGIBLE_CONFIG)\n            .await\n            .to_not_found_response(errors::ApiErrorResponse::ConfigNotFound)?;\n        let auth_eligible_array: Vec<String> =\n            serde_json::from_str(&merchants_eligible_for_authentication_service.config)\n                .change_context(errors::ApiErrorResponse::InternalServerError)\n                .attach_printable(\"unable to parse authentication service config\")?;\n        let merchant_id = merchant_account.get_id();\n\n        if auth_eligible_array.contains(&merchant_id.get_string_repr().to_owned()) {\n            let authentication_product_ids = business_profile\n                .authentication_product_ids\n                .clone()\n                .ok_or(errors::ApiErrorResponse::PreconditionFailed {\n                    message: \"authentication_product_ids is not configured in business profile\"\n                        .to_string(),\n                })?;\n            operation\n                .to_domain()?\n                .call_unified_authentication_service_if_eligible(\n                    state,\n                    &mut payment_data,\n                    &mut should_continue_transaction,\n                    &connector_details,\n                    &business_profile,\n                    &key_store,\n                    &authentication_product_ids,\n                )\n                .await?;\n        } else {\n            logger::info!(\n                \"skipping authentication service call since the merchant is not eligible.\"\n            )\n        };\n",
+        "after": "            logger::info!(\n                \"skipping authentication service call since the merchant is not eligible.\"\n            );\n\n            operation\n                .to_domain()?\n                .call_external_three_ds_authentication_if_eligible(\n                    state,\n                    &mut payment_data,\n                    &mut should_continue_transaction,\n                    &connector_details,\n                    &business_profile,\n                    &key_store,\n                    mandate_type,\n                )\n                .await?;\n        };\n"
+      },
+      "commit_sha": "98b5af4ea8c7c5b79a37b61a88eae1463397e6ff"
+    }
+  ]
+}

diffs/pr_6859/a0ea8e7/diff.json

@@ -0,0 +1,6 @@
+{
+  "commit_sha": "a0ea8e7c10c000b3a6177e50baf4f130c9b4ba91",
+  "pr_number": 6859,
+  "rust_files": [],
+  "diffs": []
+}

diffs/pr_6859/a97f01e/diff.json

@@ -0,0 +1,6 @@
+{
+  "commit_sha": "a97f01eeaca1ac9baedcac357835702653eaaa96",
+  "pr_number": 6859,
+  "rust_files": [],
+  "diffs": []
+}

diffs/pr_6859/c6bc417/diff.json

@@ -0,0 +1,6 @@
+{
+  "commit_sha": "c6bc41713bd5c26b0f19ec7bbd3415d743b0374e",
+  "pr_number": 6859,
+  "rust_files": [],
+  "diffs": []
+}

diffs/pr_6859/c7a0b06/diff.json

@@ -0,0 +1,6 @@
+{
+  "commit_sha": "c7a0b06db2e063fff440604d171575041e8143ed",
+  "pr_number": 6859,
+  "rust_files": [],
+  "diffs": []
+}

diffs/pr_6859/edae612/diff.json

@@ -0,0 +1,6 @@
+{
+  "commit_sha": "edae612175c69435f4c12c9276981d05a3130387",
+  "pr_number": 6859,
+  "rust_files": [],
+  "diffs": []
+}