repo stringlengths 6 65 | file_url stringlengths 81 311 | file_path stringlengths 6 227 | content stringlengths 0 32.8k | language stringclasses 1
value | license stringclasses 7
values | commit_sha stringlengths 40 40 | retrieved_at stringdate 2026-01-04 15:31:58 2026-01-04 20:25:31 | truncated bool 2
classes |
|---|---|---|---|---|---|---|---|---|
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/payments/gateway/psync_gateway.rs | crates/router/src/core/payments/gateway/psync_gateway.rs | use std::str::FromStr;
use async_trait::async_trait;
use common_enums::{CallConnectorAction, ExecutionPath};
use common_utils::{errors::CustomResult, id_type, request::Request, ucs_types};
use error_stack::ResultExt;
use hyperswitch_domain_models::{router_data::RouterData, router_flow_types as domain};
use hyperswitch_interfaces::{
api::gateway as payment_gateway,
connector_integration_interface::{BoxedConnectorIntegrationInterface, RouterDataConversion},
errors::ConnectorError,
unified_connector_service::handle_unified_connector_service_response_for_payment_get,
};
use unified_connector_service_client::payments as payments_grpc;
use unified_connector_service_masking::ExposeInterface as UcsMaskingExposeInterface;
use crate::{
core::{
payments::gateway::context::RouterGatewayContext,
unified_connector_service::{self, extract_connector_response_from_ucs},
},
routes::SessionState,
services::logger,
types::{self, transformers::ForeignTryFrom, MinorUnit},
};
// =============================================================================
// PaymentGateway Implementation for domain::PSync
// =============================================================================
/// Implementation of PaymentGateway for api::PSync flow
#[async_trait]
impl<RCD>
payment_gateway::PaymentGateway<
SessionState,
RCD,
Self,
types::PaymentsSyncData,
types::PaymentsResponseData,
RouterGatewayContext,
> for domain::PSync
where
RCD: Clone
+ Send
+ Sync
+ 'static
+ RouterDataConversion<Self, types::PaymentsSyncData, types::PaymentsResponseData>,
{
async fn execute(
self: Box<Self>,
state: &SessionState,
_connector_integration: BoxedConnectorIntegrationInterface<
Self,
RCD,
types::PaymentsSyncData,
types::PaymentsResponseData,
>,
router_data: &RouterData<Self, types::PaymentsSyncData, types::PaymentsResponseData>,
call_connector_action: CallConnectorAction,
_connector_request: Option<Request>,
_return_raw_connector_response: Option<bool>,
context: RouterGatewayContext,
) -> CustomResult<
RouterData<Self, types::PaymentsSyncData, types::PaymentsResponseData>,
ConnectorError,
> {
let connector_name = router_data.connector.clone();
let connector_enum = common_enums::connector_enums::Connector::from_str(&connector_name)
.change_context(ConnectorError::InvalidConnectorName)?;
let merchant_connector_account = context.merchant_connector_account;
let creds_identifier = context.creds_identifier;
let platform = context.platform;
let lineage_ids = context.lineage_ids;
let header_payload = context.header_payload;
let unified_connector_service_execution_mode = context.execution_mode;
let merchant_order_reference_id = header_payload.x_reference_id.clone();
let is_ucs_psync_disabled = state
.conf
.grpc_client
.unified_connector_service
.as_ref()
.is_some_and(|config| {
config
.ucs_psync_disabled_connectors
.contains(&connector_enum)
});
if is_ucs_psync_disabled {
logger::info!(
"UCS PSync call disabled for connector: {}, skipping UCS call",
connector_name
);
return Ok(router_data.clone());
}
let client = state
.grpc_client
.unified_connector_service_client
.clone()
.ok_or(ConnectorError::RequestEncodingFailed)
.attach_printable("Failed to fetch Unified Connector Service client")?;
let payment_get_request = payments_grpc::PaymentServiceGetRequest::foreign_try_from((
router_data,
call_connector_action,
))
.change_context(ConnectorError::RequestEncodingFailed)
.attach_printable("Failed to construct Payment Get Request")?;
let merchant_connector_id = merchant_connector_account.get_mca_id();
let connector_auth_metadata =
unified_connector_service::build_unified_connector_service_auth_metadata(
merchant_connector_account,
&platform,
router_data.connector.clone(),
)
.change_context(ConnectorError::RequestEncodingFailed)
.attach_printable("Failed to construct request metadata")?;
let merchant_reference_id = header_payload
.x_reference_id
.clone()
.or(merchant_order_reference_id)
.map(|id| id_type::PaymentReferenceId::from_str(id.as_str()))
.transpose()
.inspect_err(|err| logger::warn!(error=?err, "Invalid Merchant ReferenceId found"))
.ok()
.flatten()
.map(ucs_types::UcsReferenceId::Payment);
let header_payload = state
.get_grpc_headers_ucs(unified_connector_service_execution_mode)
.external_vault_proxy_metadata(None)
.merchant_reference_id(merchant_reference_id)
.lineage_ids(lineage_ids);
let connector_name = router_data.connector.clone();
Box::pin(unified_connector_service::ucs_logging_wrapper_granular(
router_data.clone(),
state,
payment_get_request,
header_payload,
|mut router_data, payment_get_request, grpc_headers| async move {
let response = client
.payment_get(payment_get_request, connector_auth_metadata, grpc_headers)
.await
.attach_printable("Failed to get payment")?;
let payment_get_response = response.into_inner();
let (router_data_response, status_code) =
handle_unified_connector_service_response_for_payment_get(
payment_get_response.clone(),
)
.attach_printable("Failed to deserialize UCS response")?;
// Extract and store access token if present
if let Some(access_token) =
unified_connector_service::get_access_token_from_ucs_response(
state,
&platform,
&connector_name,
merchant_connector_id.as_ref(),
creds_identifier.clone(),
payment_get_response.state.as_ref(),
)
.await
{
if let Err(error) = unified_connector_service::set_access_token_for_ucs(
state,
&platform,
&connector_name,
access_token,
merchant_connector_id.as_ref(),
creds_identifier,
)
.await
{
logger::error!(
?error,
"Failed to store UCS access token from psync response"
);
} else {
logger::debug!("Successfully stored access token from UCS psync response");
}
}
let router_data_response = router_data_response.map(|(response, status)| {
router_data.status = status;
response
});
let connector_response = extract_connector_response_from_ucs(
payment_get_response.connector_response.as_ref(),
);
if let Some(connector_response) = connector_response {
router_data.connector_response = Some(connector_response);
}
router_data.response = router_data_response;
router_data.amount_captured = payment_get_response.captured_amount;
router_data.minor_amount_captured = payment_get_response
.minor_captured_amount
.map(MinorUnit::new);
router_data.raw_connector_response = payment_get_response
.raw_connector_response
.clone()
.map(|raw_connector_response| raw_connector_response.expose().into());
router_data.connector_http_status_code = Some(status_code);
Ok((router_data, (), payment_get_response))
},
))
.await
.map(|(router_data, _)| router_data)
.change_context(ConnectorError::ResponseHandlingFailed)
}
}
/// Implementation of FlowGateway for api::PSync
///
/// This allows the flow to provide its specific gateway based on execution path
impl<RCD>
payment_gateway::FlowGateway<
SessionState,
RCD,
types::PaymentsSyncData,
types::PaymentsResponseData,
RouterGatewayContext,
> for domain::PSync
where
RCD: Clone
+ Send
+ Sync
+ 'static
+ RouterDataConversion<Self, types::PaymentsSyncData, types::PaymentsResponseData>,
{
fn get_gateway(
execution_path: ExecutionPath,
) -> Box<
dyn payment_gateway::PaymentGateway<
SessionState,
RCD,
Self,
types::PaymentsSyncData,
types::PaymentsResponseData,
RouterGatewayContext,
>,
> {
match execution_path {
ExecutionPath::Direct => Box::new(payment_gateway::DirectGateway),
ExecutionPath::UnifiedConnectorService
| ExecutionPath::ShadowUnifiedConnectorService => Box::new(Self),
}
}
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/payments/gateway/capture_gateway.rs | crates/router/src/core/payments/gateway/capture_gateway.rs | use std::str::FromStr;
use async_trait::async_trait;
use common_enums::{CallConnectorAction, ExecutionPath};
use common_utils::{errors::CustomResult, id_type, request::Request, ucs_types};
use error_stack::ResultExt;
use hyperswitch_domain_models::{router_data::RouterData, router_flow_types as domain};
use hyperswitch_interfaces::{
api::gateway as payment_gateway,
connector_integration_interface::{BoxedConnectorIntegrationInterface, RouterDataConversion},
errors::ConnectorError,
};
use unified_connector_service_client::payments as payments_grpc;
use crate::{
core::{payments::gateway::context::RouterGatewayContext, unified_connector_service},
routes::SessionState,
services::logger,
types::{self, transformers::ForeignTryFrom, MinorUnit},
};
// =============================================================================
// PaymentGateway Implementation for domain::Capture
// =============================================================================
/// Implementation of PaymentGateway for api::Capture flow
#[async_trait]
impl<RCD>
payment_gateway::PaymentGateway<
SessionState,
RCD,
Self,
types::PaymentsCaptureData,
types::PaymentsResponseData,
RouterGatewayContext,
> for domain::Capture
where
RCD: Clone
+ Send
+ Sync
+ 'static
+ RouterDataConversion<Self, types::PaymentsCaptureData, types::PaymentsResponseData>,
{
async fn execute(
self: Box<Self>,
state: &SessionState,
_connector_integration: BoxedConnectorIntegrationInterface<
Self,
RCD,
types::PaymentsCaptureData,
types::PaymentsResponseData,
>,
router_data: &RouterData<Self, types::PaymentsCaptureData, types::PaymentsResponseData>,
_call_connector_action: CallConnectorAction,
_connector_request: Option<Request>,
_return_raw_connector_response: Option<bool>,
context: RouterGatewayContext,
) -> CustomResult<
RouterData<Self, types::PaymentsCaptureData, types::PaymentsResponseData>,
ConnectorError,
> {
let merchant_connector_account = context.merchant_connector_account;
let platform = &context.platform;
let lineage_ids = context.lineage_ids;
let header_payload = context.header_payload;
let unified_connector_service_execution_mode = context.execution_mode;
let merchant_order_reference_id = header_payload.x_reference_id.clone();
let client = state
.grpc_client
.unified_connector_service_client
.clone()
.ok_or(ConnectorError::RequestEncodingFailed)
.attach_printable("Failed to fetch Unified Connector Service client")?;
let payment_capture_request =
payments_grpc::PaymentServiceCaptureRequest::foreign_try_from(router_data)
.change_context(ConnectorError::RequestEncodingFailed)
.attach_printable("Failed to construct Payment Capture Request")?;
let connector_auth_metadata =
unified_connector_service::build_unified_connector_service_auth_metadata(
merchant_connector_account,
platform,
router_data.connector.clone(),
)
.change_context(ConnectorError::RequestEncodingFailed)
.attach_printable("Failed to construct request metadata")?;
let merchant_reference_id = header_payload
.x_reference_id
.clone()
.or(merchant_order_reference_id)
.map(|id| id_type::PaymentReferenceId::from_str(id.as_str()))
.transpose()
.inspect_err(|err| logger::warn!(error=?err, "Invalid Merchant ReferenceId found"))
.ok()
.flatten()
.map(ucs_types::UcsReferenceId::Payment);
let header_payload = state
.get_grpc_headers_ucs(unified_connector_service_execution_mode)
.external_vault_proxy_metadata(None)
.merchant_reference_id(merchant_reference_id)
.lineage_ids(lineage_ids);
Box::pin(unified_connector_service::ucs_logging_wrapper_granular(
router_data.clone(),
state,
payment_capture_request,
header_payload,
|mut router_data, payment_capture_request, grpc_headers| async move {
let response = client
.payment_capture(
payment_capture_request,
connector_auth_metadata,
grpc_headers,
)
.await
.attach_printable("Failed to capture payment")?;
let payment_capture_response = response.into_inner();
let (router_data_response, status_code) =
unified_connector_service::handle_unified_connector_service_response_for_payment_capture(
payment_capture_response.clone(),
)
.attach_printable("Failed to deserialize UCS response")?;
let router_data_response = router_data_response.map(|(response, status)| {
router_data.status = status;
response
});
router_data.response = router_data_response;
router_data.amount_captured = payment_capture_response.captured_amount;
router_data.minor_amount_captured = payment_capture_response
.minor_captured_amount
.map(MinorUnit::new);
router_data.connector_http_status_code = Some(status_code);
Ok((router_data, (), payment_capture_response))
},
))
.await
.map(|(router_data, _)| router_data)
.change_context(ConnectorError::ResponseHandlingFailed)
}
}
/// Implementation of FlowGateway for api::PSync
///
/// This allows the flow to provide its specific gateway based on execution path
impl<RCD>
payment_gateway::FlowGateway<
SessionState,
RCD,
types::PaymentsCaptureData,
types::PaymentsResponseData,
RouterGatewayContext,
> for domain::Capture
where
RCD: Clone
+ Send
+ Sync
+ 'static
+ RouterDataConversion<Self, types::PaymentsCaptureData, types::PaymentsResponseData>,
{
fn get_gateway(
execution_path: ExecutionPath,
) -> Box<
dyn payment_gateway::PaymentGateway<
SessionState,
RCD,
Self,
types::PaymentsCaptureData,
types::PaymentsResponseData,
RouterGatewayContext,
>,
> {
match execution_path {
ExecutionPath::Direct => Box::new(payment_gateway::DirectGateway),
ExecutionPath::UnifiedConnectorService
| ExecutionPath::ShadowUnifiedConnectorService => Box::new(Self),
}
}
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/payments/gateway/create_order_gateway.rs | crates/router/src/core/payments/gateway/create_order_gateway.rs | use std::str::FromStr;
use async_trait::async_trait;
use common_enums::{CallConnectorAction, ExecutionPath};
use common_utils::{errors::CustomResult, id_type, request::Request, ucs_types};
use error_stack::ResultExt;
use hyperswitch_domain_models::{router_data::RouterData, router_flow_types as domain};
use hyperswitch_interfaces::{
api::gateway as payment_gateway,
connector_integration_interface::{BoxedConnectorIntegrationInterface, RouterDataConversion},
errors::ConnectorError,
};
use unified_connector_service_client::payments as payments_grpc;
use crate::{
core::{
payments::gateway::context::RouterGatewayContext,
unified_connector_service::{
self, handle_unified_connector_service_response_for_create_order,
},
},
routes::SessionState,
services::logger,
types::{self, transformers::ForeignTryFrom},
};
// =============================================================================
// PaymentGateway Implementation for domain::CreateOrder
// =============================================================================
/// Implementation of PaymentGateway for api::CreateOrder flow
#[async_trait]
impl<RCD>
payment_gateway::PaymentGateway<
SessionState,
RCD,
Self,
types::CreateOrderRequestData,
types::PaymentsResponseData,
RouterGatewayContext,
> for domain::CreateOrder
where
RCD: Clone
+ Send
+ Sync
+ 'static
+ RouterDataConversion<Self, types::CreateOrderRequestData, types::PaymentsResponseData>,
{
async fn execute(
self: Box<Self>,
state: &SessionState,
_connector_integration: BoxedConnectorIntegrationInterface<
Self,
RCD,
types::CreateOrderRequestData,
types::PaymentsResponseData,
>,
router_data: &RouterData<Self, types::CreateOrderRequestData, types::PaymentsResponseData>,
_call_connector_action: CallConnectorAction,
_connector_request: Option<Request>,
_return_raw_connector_response: Option<bool>,
context: RouterGatewayContext,
) -> CustomResult<
RouterData<Self, types::CreateOrderRequestData, types::PaymentsResponseData>,
ConnectorError,
> {
let merchant_connector_account = context.merchant_connector_account;
let platform = context.platform;
let lineage_ids = context.lineage_ids;
let header_payload = context.header_payload;
let unified_connector_service_execution_mode = context.execution_mode;
let merchant_order_reference_id = header_payload.x_reference_id.clone();
let client = state
.grpc_client
.unified_connector_service_client
.clone()
.ok_or(ConnectorError::RequestEncodingFailed)
.attach_printable("Failed to fetch Unified Connector Service client")?;
let create_order_request =
payments_grpc::PaymentServiceCreateOrderRequest::foreign_try_from(router_data)
.change_context(ConnectorError::RequestEncodingFailed)
.attach_printable("Failed to construct Payment Create Order Request")?;
let connector_auth_metadata =
unified_connector_service::build_unified_connector_service_auth_metadata(
merchant_connector_account,
&platform,
router_data.connector.clone(),
)
.change_context(ConnectorError::RequestEncodingFailed)
.attach_printable("Failed to construct request metadata")?;
let merchant_reference_id = header_payload
.x_reference_id
.clone()
.or(merchant_order_reference_id)
.map(|id| id_type::PaymentReferenceId::from_str(id.as_str()))
.transpose()
.inspect_err(|err| logger::warn!(error=?err, "Invalid Merchant ReferenceId found"))
.ok()
.flatten()
.map(ucs_types::UcsReferenceId::Payment);
let header_payload = state
.get_grpc_headers_ucs(unified_connector_service_execution_mode)
.external_vault_proxy_metadata(None)
.merchant_reference_id(merchant_reference_id)
.lineage_ids(lineage_ids);
Box::pin(unified_connector_service::ucs_logging_wrapper_granular(
router_data.clone(),
state,
create_order_request,
header_payload,
|mut router_data, create_order_request, grpc_headers| async move {
let response = Box::pin(client.payment_create_order(
create_order_request,
connector_auth_metadata,
grpc_headers,
))
.await
.attach_printable("Failed to create order")?;
let create_order_response = response.into_inner();
let (router_data_response, status_code) =
handle_unified_connector_service_response_for_create_order(
create_order_response.clone(),
)
.attach_printable("Failed to deserialize UCS response")?;
router_data.response = router_data_response;
router_data.connector_http_status_code = Some(status_code);
Ok((router_data, (), create_order_response))
},
))
.await
.map(|(router_data, _)| router_data)
.change_context(ConnectorError::ResponseHandlingFailed)
}
}
/// Implementation of FlowGateway for api::CreateOrder
///
/// This allows the flow to provide its specific gateway based on execution path
impl<RCD>
payment_gateway::FlowGateway<
SessionState,
RCD,
types::CreateOrderRequestData,
types::PaymentsResponseData,
RouterGatewayContext,
> for domain::CreateOrder
where
RCD: Clone
+ Send
+ Sync
+ 'static
+ RouterDataConversion<Self, types::CreateOrderRequestData, types::PaymentsResponseData>,
{
fn get_gateway(
execution_path: ExecutionPath,
) -> Box<
dyn payment_gateway::PaymentGateway<
SessionState,
RCD,
Self,
types::CreateOrderRequestData,
types::PaymentsResponseData,
RouterGatewayContext,
>,
> {
match execution_path {
ExecutionPath::Direct => Box::new(payment_gateway::DirectGateway),
ExecutionPath::UnifiedConnectorService
| ExecutionPath::ShadowUnifiedConnectorService => Box::new(Self),
}
}
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/payments/gateway/post_authenticate_gateway.rs | crates/router/src/core/payments/gateway/post_authenticate_gateway.rs | use async_trait::async_trait;
use common_enums::{CallConnectorAction, ExecutionPath};
use common_utils::{errors::CustomResult, request::Request};
use hyperswitch_domain_models::{
router_data::RouterData, router_flow_types as domain, router_request_types,
};
use hyperswitch_interfaces::{
api::gateway as payment_gateway,
connector_integration_interface::{BoxedConnectorIntegrationInterface, RouterDataConversion},
errors::ConnectorError,
};
use crate::{
core::payments::{flows::complete_authorize_flow, gateway::context::RouterGatewayContext},
routes::SessionState,
types,
};
// =============================================================================
// PaymentGateway Implementation for domain::PostAuthenticate
// =============================================================================
/// Implementation of PaymentGateway for api::PostAuthenticate flow
#[async_trait]
impl<RCD>
payment_gateway::PaymentGateway<
SessionState,
RCD,
Self,
types::PaymentsPostAuthenticateData,
types::PaymentsResponseData,
RouterGatewayContext,
(
RouterData<Self, types::PaymentsPostAuthenticateData, types::PaymentsResponseData>,
Option<router_request_types::UcsAuthenticationData>,
),
> for domain::PostAuthenticate
where
RCD: Clone
+ Send
+ Sync
+ 'static
+ RouterDataConversion<Self, types::PaymentsPostAuthenticateData, types::PaymentsResponseData>,
{
async fn execute(
self: Box<Self>,
state: &SessionState,
_connector_integration: BoxedConnectorIntegrationInterface<
Self,
RCD,
types::PaymentsPostAuthenticateData,
types::PaymentsResponseData,
>,
router_data: &RouterData<
Self,
types::PaymentsPostAuthenticateData,
types::PaymentsResponseData,
>,
_call_connector_action: CallConnectorAction,
_connector_request: Option<Request>,
_return_raw_connector_response: Option<bool>,
context: RouterGatewayContext,
) -> CustomResult<
(
RouterData<Self, types::PaymentsPostAuthenticateData, types::PaymentsResponseData>,
Option<router_request_types::UcsAuthenticationData>,
),
ConnectorError,
> {
let merchant_connector_account = context.merchant_connector_account;
let platform = context.platform;
let lineage_ids = context.lineage_ids;
let header_payload = context.header_payload;
let unified_connector_service_execution_mode = context.execution_mode;
let merchant_order_reference_id = header_payload.x_reference_id.clone();
complete_authorize_flow::call_unified_connector_service_post_authenticate(
router_data,
state,
&header_payload,
lineage_ids,
merchant_connector_account,
&platform,
unified_connector_service_execution_mode,
merchant_order_reference_id,
)
.await
}
}
/// Implementation of FlowGateway for api::PSync
///
/// This allows the flow to provide its specific gateway based on execution path
impl<RCD>
payment_gateway::FlowGateway<
SessionState,
RCD,
types::PaymentsPostAuthenticateData,
types::PaymentsResponseData,
RouterGatewayContext,
(
RouterData<Self, types::PaymentsPostAuthenticateData, types::PaymentsResponseData>,
Option<router_request_types::UcsAuthenticationData>,
),
> for domain::PostAuthenticate
where
RCD: Clone
+ Send
+ Sync
+ 'static
+ RouterDataConversion<Self, types::PaymentsPostAuthenticateData, types::PaymentsResponseData>,
{
fn get_gateway(
execution_path: ExecutionPath,
) -> Box<
dyn payment_gateway::PaymentGateway<
SessionState,
RCD,
Self,
types::PaymentsPostAuthenticateData,
types::PaymentsResponseData,
RouterGatewayContext,
(
RouterData<Self, types::PaymentsPostAuthenticateData, types::PaymentsResponseData>,
Option<router_request_types::UcsAuthenticationData>,
),
>,
> {
match execution_path {
ExecutionPath::Direct => Box::new(payment_gateway::DirectGateway),
ExecutionPath::UnifiedConnectorService
| ExecutionPath::ShadowUnifiedConnectorService => Box::new(Self),
}
}
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/payments/gateway/context.rs | crates/router/src/core/payments/gateway/context.rs | //! Gateway execution context for router crate
//!
//! This module defines the RouterGatewayContext type, which contains all the
//! information needed for executing payment operations through either direct
//! connector integration or Unified Connector Service (UCS).
use common_enums::{ExecutionMode, ExecutionPath, GatewaySystem};
use common_utils::id_type;
use external_services::grpc_client::LineageIds;
use hyperswitch_domain_models::{business_profile, payments::HeaderPayload, platform::Platform};
use hyperswitch_interfaces::api::gateway::GatewayContext;
use crate::core::payments::helpers;
/// Router's gateway execution context
///
/// This is the router crate's implementation of gateway context. It contains
/// all the information needed for both direct connector execution and UCS execution.
#[derive(Clone, Debug)]
pub struct RouterGatewayContext {
pub creds_identifier: Option<String>,
/// Merchant context (merchant_id, profile_id, etc.)
pub platform: Platform,
/// Header payload (x-reference-id, etc.)
pub header_payload: HeaderPayload,
/// Lineage IDs for distributed tracing
pub lineage_ids: LineageIds,
/// Merchant connector account details
#[cfg(feature = "v1")]
pub merchant_connector_account: helpers::MerchantConnectorAccountType,
/// Merchant connector account details (v2)
#[cfg(feature = "v2")]
pub merchant_connector_account:
hyperswitch_domain_models::merchant_connector_account::MerchantConnectorAccountTypeDetails,
/// Execution mode (Primary, Shadow, etc.)
pub execution_mode: ExecutionMode,
/// Execution path (Direct, UCS, or Shadow)
pub execution_path: ExecutionPath,
}
impl RouterGatewayContext {
pub fn new(
platform: Platform,
header_payload: HeaderPayload,
business_profile: &business_profile::Profile,
#[cfg(feature = "v1")] merchant_connector_account: helpers::MerchantConnectorAccountType,
#[cfg(feature = "v2")]
merchant_connector_account: hyperswitch_domain_models::merchant_connector_account::MerchantConnectorAccountTypeDetails,
execution_path: ExecutionPath,
creds_identifier: Option<String>,
) -> Self {
let lineage_ids = LineageIds::new(
business_profile.merchant_id.clone(),
business_profile.get_id().clone(),
);
let execution_mode = match execution_path {
ExecutionPath::UnifiedConnectorService => ExecutionMode::Primary,
ExecutionPath::ShadowUnifiedConnectorService => ExecutionMode::Shadow,
// ExecutionMode is irrelevant for Direct path in this context
ExecutionPath::Direct => ExecutionMode::NotApplicable,
};
Self {
platform,
header_payload,
lineage_ids,
merchant_connector_account,
execution_mode,
execution_path,
creds_identifier,
}
}
pub fn direct(
platform: Platform,
#[cfg(feature = "v1")] merchant_connector_account: helpers::MerchantConnectorAccountType,
#[cfg(feature = "v2")]
merchant_connector_account: hyperswitch_domain_models::merchant_connector_account::MerchantConnectorAccountTypeDetails,
merchant_id: id_type::MerchantId,
profile_id: id_type::ProfileId,
creds_identifier: Option<String>,
) -> Self {
let lineage_ids = LineageIds::new(merchant_id, profile_id);
Self {
platform,
header_payload: HeaderPayload::default(),
lineage_ids,
merchant_connector_account,
execution_mode: ExecutionMode::NotApplicable,
execution_path: ExecutionPath::Direct,
creds_identifier,
}
}
}
/// Implementation of GatewayContext trait for RouterGatewayContext
///
/// This allows the framework to extract execution metadata without knowing
/// the concrete structure of RouterGatewayContext.
impl GatewayContext for RouterGatewayContext {
fn execution_path(&self) -> ExecutionPath {
self.execution_path
}
/// Get the execution mode (Primary, Shadow, etc.)
fn execution_mode(&self) -> ExecutionMode {
self.execution_mode
}
}
impl RouterGatewayContext {
/// Get the gateway system (Direct, UnifiedConnectorService, etc.)
pub fn get_gateway_system(&self) -> GatewaySystem {
match self.execution_path {
ExecutionPath::Direct => GatewaySystem::Direct,
ExecutionPath::UnifiedConnectorService => GatewaySystem::UnifiedConnectorService,
ExecutionPath::ShadowUnifiedConnectorService => GatewaySystem::Direct,
}
}
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/payments/gateway/complete_authorize_gateway.rs | crates/router/src/core/payments/gateway/complete_authorize_gateway.rs | use std::str::FromStr;
use async_trait::async_trait;
use common_enums::{CallConnectorAction, ExecutionPath};
use common_utils::{errors::CustomResult, id_type, request::Request, ucs_types};
use error_stack::ResultExt;
use hyperswitch_domain_models::{router_data::RouterData, router_flow_types as domain};
use hyperswitch_interfaces::{
api::gateway as payment_gateway,
connector_integration_interface::{BoxedConnectorIntegrationInterface, RouterDataConversion},
errors::ConnectorError,
};
use unified_connector_service_client::payments as payments_grpc;
use unified_connector_service_masking::ExposeInterface as UcsMaskingExposeInterface;
use crate::{
core::{
payments::gateway::context::RouterGatewayContext, unified_connector_service,
unified_connector_service::handle_unified_connector_service_response_for_payment_authorize,
},
routes::SessionState,
services::logger,
types::{self, transformers::ForeignTryFrom, MinorUnit},
};
// =============================================================================
// PaymentGateway Implementation for domain::CompleteAuthorize
// =============================================================================
/// Implementation of PaymentGateway for api::CompleteAuthorize flow
#[async_trait]
impl<RCD>
payment_gateway::PaymentGateway<
SessionState,
RCD,
Self,
types::CompleteAuthorizeData,
types::PaymentsResponseData,
RouterGatewayContext,
> for domain::CompleteAuthorize
where
RCD: Clone
+ Send
+ Sync
+ 'static
+ RouterDataConversion<Self, types::CompleteAuthorizeData, types::PaymentsResponseData>,
{
async fn execute(
self: Box<Self>,
state: &SessionState,
_connector_integration: BoxedConnectorIntegrationInterface<
Self,
RCD,
types::CompleteAuthorizeData,
types::PaymentsResponseData,
>,
router_data: &RouterData<Self, types::CompleteAuthorizeData, types::PaymentsResponseData>,
call_connector_action: CallConnectorAction,
_connector_request: Option<Request>,
_return_raw_connector_response: Option<bool>,
context: RouterGatewayContext,
) -> CustomResult<
RouterData<Self, types::CompleteAuthorizeData, types::PaymentsResponseData>,
ConnectorError,
> {
let merchant_connector_account = context.merchant_connector_account;
let platform = context.platform;
let lineage_ids = context.lineage_ids;
let header_payload = context.header_payload;
let unified_connector_service_execution_mode = context.execution_mode;
let merchant_order_reference_id = header_payload.x_reference_id.clone();
let client = state
.grpc_client
.unified_connector_service_client
.clone()
.ok_or(ConnectorError::RequestEncodingFailed)
.attach_printable("Failed to fetch Unified Connector Service client")?;
let granular_authorize_request =
payments_grpc::PaymentServiceAuthorizeOnlyRequest::foreign_try_from((
router_data,
call_connector_action,
))
.change_context(ConnectorError::RequestEncodingFailed)
.attach_printable("Failed to construct Payment Get Request")?;
let connector_auth_metadata =
unified_connector_service::build_unified_connector_service_auth_metadata(
merchant_connector_account,
&platform,
router_data.connector.clone(),
)
.change_context(ConnectorError::RequestEncodingFailed)
.attach_printable("Failed to construct request metadata")?;
let merchant_reference_id = header_payload
.x_reference_id
.clone()
.or(merchant_order_reference_id)
.map(|id| id_type::PaymentReferenceId::from_str(id.as_str()))
.transpose()
.inspect_err(|err| logger::warn!(error=?err, "Invalid Merchant ReferenceId found"))
.ok()
.flatten()
.map(ucs_types::UcsReferenceId::Payment);
let header_payload = state
.get_grpc_headers_ucs(unified_connector_service_execution_mode)
.external_vault_proxy_metadata(None)
.merchant_reference_id(merchant_reference_id)
.lineage_ids(lineage_ids);
Box::pin(unified_connector_service::ucs_logging_wrapper_granular(
router_data.clone(),
state,
granular_authorize_request,
header_payload,
|mut router_data, granular_authorize_request, grpc_headers| async move {
let response = Box::pin(client.payment_authorize_granular(
granular_authorize_request,
connector_auth_metadata,
grpc_headers,
))
.await
.attach_printable("Failed to get payment")?;
let payment_authorize_response = response.into_inner();
let ucs_data = handle_unified_connector_service_response_for_payment_authorize(
payment_authorize_response.clone(),
)
.attach_printable("Failed to deserialize UCS response")?;
let router_data_response =
ucs_data.router_data_response.map(|(response, status)| {
router_data.status = status;
response
});
router_data.response = router_data_response;
router_data.amount_captured = payment_authorize_response.captured_amount;
router_data.minor_amount_captured = payment_authorize_response
.minor_captured_amount
.map(MinorUnit::new);
router_data.raw_connector_response = payment_authorize_response
.raw_connector_response
.clone()
.map(|raw_connector_response| raw_connector_response.expose().into());
router_data.connector_http_status_code = Some(ucs_data.status_code);
ucs_data.connector_response.map(|customer_response| {
router_data.connector_response = Some(customer_response);
});
Ok((router_data, (), payment_authorize_response))
},
))
.await
.map(|(router_data, _)| router_data)
.change_context(ConnectorError::ResponseHandlingFailed)
}
}
/// Implementation of FlowGateway for api::PSync
///
/// This allows the flow to provide its specific gateway based on execution path
impl<RCD>
payment_gateway::FlowGateway<
SessionState,
RCD,
types::CompleteAuthorizeData,
types::PaymentsResponseData,
RouterGatewayContext,
> for domain::CompleteAuthorize
where
RCD: Clone
+ Send
+ Sync
+ 'static
+ RouterDataConversion<Self, types::CompleteAuthorizeData, types::PaymentsResponseData>,
{
fn get_gateway(
execution_path: ExecutionPath,
) -> Box<
dyn payment_gateway::PaymentGateway<
SessionState,
RCD,
Self,
types::CompleteAuthorizeData,
types::PaymentsResponseData,
RouterGatewayContext,
>,
> {
match execution_path {
ExecutionPath::Direct => Box::new(payment_gateway::DirectGateway),
ExecutionPath::UnifiedConnectorService
| ExecutionPath::ShadowUnifiedConnectorService => Box::new(Self),
}
}
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/payments/gateway/cancel_gateway.rs | crates/router/src/core/payments/gateway/cancel_gateway.rs | use std::str::FromStr;
use async_trait::async_trait;
use common_enums::{CallConnectorAction, ExecutionPath};
use common_utils::{errors::CustomResult, id_type, request::Request, ucs_types};
use error_stack::ResultExt;
use hyperswitch_domain_models::{router_data::RouterData, router_flow_types as domain};
use hyperswitch_interfaces::{
api::gateway as payment_gateway,
connector_integration_interface::{BoxedConnectorIntegrationInterface, RouterDataConversion},
errors::ConnectorError,
};
use unified_connector_service_client::payments as payments_grpc;
use crate::{
core::{payments::gateway::context::RouterGatewayContext, unified_connector_service},
routes::SessionState,
services::logger,
types::{self, transformers::ForeignTryFrom},
};
// =============================================================================
// PaymentGateway Implementation for domain::Void
// =============================================================================
/// Implementation of PaymentGateway for api::Void flow
#[async_trait]
impl<RCD>
payment_gateway::PaymentGateway<
SessionState,
RCD,
Self,
types::PaymentsCancelData,
types::PaymentsResponseData,
RouterGatewayContext,
> for domain::Void
where
RCD: Clone
+ Send
+ Sync
+ 'static
+ RouterDataConversion<Self, types::PaymentsCancelData, types::PaymentsResponseData>,
{
async fn execute(
self: Box<Self>,
state: &SessionState,
_connector_integration: BoxedConnectorIntegrationInterface<
Self,
RCD,
types::PaymentsCancelData,
types::PaymentsResponseData,
>,
router_data: &RouterData<Self, types::PaymentsCancelData, types::PaymentsResponseData>,
_call_connector_action: CallConnectorAction,
_connector_request: Option<Request>,
_return_raw_connector_response: Option<bool>,
context: RouterGatewayContext,
) -> CustomResult<
RouterData<Self, types::PaymentsCancelData, types::PaymentsResponseData>,
ConnectorError,
> {
let merchant_connector_account = context.merchant_connector_account;
let platform = &context.platform;
let lineage_ids = context.lineage_ids;
let header_payload = context.header_payload;
let unified_connector_service_execution_mode = context.execution_mode;
let merchant_order_reference_id = header_payload.x_reference_id.clone();
let client = state
.grpc_client
.unified_connector_service_client
.clone()
.ok_or(ConnectorError::RequestEncodingFailed)
.attach_printable("Failed to fetch Unified Connector Service client")?;
let payment_void_request =
payments_grpc::PaymentServiceVoidRequest::foreign_try_from(router_data)
.change_context(ConnectorError::RequestEncodingFailed)
.attach_printable("Failed to construct Payment Void Request")?;
let connector_auth_metadata =
unified_connector_service::build_unified_connector_service_auth_metadata(
merchant_connector_account,
platform,
router_data.connector.clone(),
)
.change_context(ConnectorError::RequestEncodingFailed)
.attach_printable("Failed to construct request metadata")?;
let merchant_reference_id = header_payload
.x_reference_id
.clone()
.or(merchant_order_reference_id)
.map(|id| id_type::PaymentReferenceId::from_str(id.as_str()))
.transpose()
.inspect_err(|err| logger::warn!(error=?err, "Invalid Merchant ReferenceId found"))
.ok()
.flatten()
.map(ucs_types::UcsReferenceId::Payment);
let header_payload = state
.get_grpc_headers_ucs(unified_connector_service_execution_mode)
.external_vault_proxy_metadata(None)
.merchant_reference_id(merchant_reference_id)
.lineage_ids(lineage_ids);
Box::pin(unified_connector_service::ucs_logging_wrapper_granular(
router_data.clone(),
state,
payment_void_request,
header_payload,
|mut router_data, payment_void_request, grpc_headers| async move {
let response = client
.payment_cancel(payment_void_request, connector_auth_metadata, grpc_headers)
.await
.attach_printable("Failed to Cancel payment")?;
let payment_void_response = response.into_inner();
let (router_data_response, status_code) =
unified_connector_service::handle_unified_connector_service_response_for_payment_cancel(
payment_void_response.clone(),
)
.attach_printable("Failed to deserialize UCS response")?;
let router_data_response = router_data_response.map(|(response, status)| {
router_data.status = status;
response
});
router_data.response = router_data_response;
router_data.connector_http_status_code = Some(status_code);
Ok((router_data, (), payment_void_response))
},
))
.await
.map(|(router_data, _)| router_data)
.change_context(ConnectorError::ResponseHandlingFailed)
}
}
/// Implementation of FlowGateway for api::PSync
///
/// This allows the flow to provide its specific gateway based on execution path
impl<RCD>
payment_gateway::FlowGateway<
SessionState,
RCD,
types::PaymentsCancelData,
types::PaymentsResponseData,
RouterGatewayContext,
> for domain::Void
where
RCD: Clone
+ Send
+ Sync
+ 'static
+ RouterDataConversion<Self, types::PaymentsCancelData, types::PaymentsResponseData>,
{
fn get_gateway(
execution_path: ExecutionPath,
) -> Box<
dyn payment_gateway::PaymentGateway<
SessionState,
RCD,
Self,
types::PaymentsCancelData,
types::PaymentsResponseData,
RouterGatewayContext,
>,
> {
match execution_path {
ExecutionPath::Direct => Box::new(payment_gateway::DirectGateway),
ExecutionPath::UnifiedConnectorService
| ExecutionPath::ShadowUnifiedConnectorService => Box::new(Self),
}
}
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/payments/gateway/session_gateway.rs | crates/router/src/core/payments/gateway/session_gateway.rs | use std::str::FromStr;
use async_trait::async_trait;
use common_enums::{CallConnectorAction, ExecutionPath};
use common_utils::{errors::CustomResult, id_type, request::Request, ucs_types};
use error_stack::ResultExt;
use hyperswitch_domain_models::{router_data::RouterData, router_flow_types as domain};
use hyperswitch_interfaces::{
api::gateway as payment_gateway,
connector_integration_interface::{BoxedConnectorIntegrationInterface, RouterDataConversion},
errors::ConnectorError,
};
use unified_connector_service_client::payments as payments_grpc;
use crate::{
core::{
payments::gateway::context::RouterGatewayContext,
unified_connector_service::{
self, handle_unified_connector_service_response_for_sdk_session_token,
},
},
routes::SessionState,
services::logger,
types::{self, transformers::ForeignTryFrom},
};
// =============================================================================
// PaymentGateway Implementation for domain::Session
// =============================================================================
/// Implementation of PaymentGateway for api::Session flow
#[async_trait]
impl<RCD>
payment_gateway::PaymentGateway<
SessionState,
RCD,
Self,
types::PaymentsSessionData,
types::PaymentsResponseData,
RouterGatewayContext,
> for domain::Session
where
RCD: Clone
+ Send
+ Sync
+ 'static
+ RouterDataConversion<Self, types::PaymentsSessionData, types::PaymentsResponseData>,
{
async fn execute(
self: Box<Self>,
state: &SessionState,
_connector_integration: BoxedConnectorIntegrationInterface<
Self,
RCD,
types::PaymentsSessionData,
types::PaymentsResponseData,
>,
router_data: &RouterData<Self, types::PaymentsSessionData, types::PaymentsResponseData>,
_call_connector_action: CallConnectorAction,
_connector_request: Option<Request>,
_return_raw_connector_response: Option<bool>,
context: RouterGatewayContext,
) -> CustomResult<
RouterData<Self, types::PaymentsSessionData, types::PaymentsResponseData>,
ConnectorError,
> {
let merchant_connector_account = context.merchant_connector_account;
let platform = context.platform;
let lineage_ids = context.lineage_ids;
let header_payload = context.header_payload;
let unified_connector_service_execution_mode = context.execution_mode;
let merchant_order_reference_id = header_payload.x_reference_id.clone();
let client = state
.grpc_client
.unified_connector_service_client
.clone()
.ok_or(ConnectorError::RequestEncodingFailed)
.attach_printable("Failed to fetch Unified Connector Service client")?;
let sdk_session_token_request =
payments_grpc::PaymentServiceSdkSessionTokenRequest::foreign_try_from(router_data)
.change_context(ConnectorError::RequestEncodingFailed)
.attach_printable("Failed to construct Payment SdkSessionToken Request")?;
let connector_auth_metadata =
unified_connector_service::build_unified_connector_service_auth_metadata(
merchant_connector_account,
&platform,
router_data.connector.clone(),
)
.change_context(ConnectorError::RequestEncodingFailed)
.attach_printable("Failed to construct request metadata")?;
let merchant_reference_id = header_payload
.x_reference_id
.clone()
.or(merchant_order_reference_id)
.map(|id| id_type::PaymentReferenceId::from_str(id.as_str()))
.transpose()
.inspect_err(|err| logger::warn!(error=?err, "Invalid Merchant ReferenceId found"))
.ok()
.flatten()
.map(ucs_types::UcsReferenceId::Payment);
let header_payload = state
.get_grpc_headers_ucs(unified_connector_service_execution_mode)
.external_vault_proxy_metadata(None)
.merchant_reference_id(merchant_reference_id)
.lineage_ids(lineage_ids);
let updated_router_data =
Box::pin(unified_connector_service::ucs_logging_wrapper_granular(
router_data.clone(),
state,
sdk_session_token_request,
header_payload,
|mut router_data, sdk_session_token_request, grpc_headers| async move {
let response = Box::pin(client.sdk_session_token(
sdk_session_token_request,
connector_auth_metadata,
grpc_headers,
))
.await
.attach_printable("Failed to get payment")?;
let sdk_session_token_response = response.into_inner();
let (router_data_response, status_code) =
handle_unified_connector_service_response_for_sdk_session_token(
sdk_session_token_response.clone(),
)
.attach_printable("Failed to deserialize UCS response")?;
router_data.response = router_data_response;
router_data.connector_http_status_code = Some(status_code);
Ok((router_data, (), sdk_session_token_response))
},
))
.await
.map(|(router_data, _)| router_data)
.change_context(ConnectorError::ResponseHandlingFailed)?;
Ok(updated_router_data)
}
}
/// Implementation of FlowGateway for api::Session
///
/// This allows the flow to provide its specific gateway based on execution path
impl<RCD>
payment_gateway::FlowGateway<
SessionState,
RCD,
types::PaymentsSessionData,
types::PaymentsResponseData,
RouterGatewayContext,
> for domain::Session
where
RCD: Clone
+ Send
+ Sync
+ 'static
+ RouterDataConversion<Self, types::PaymentsSessionData, types::PaymentsResponseData>,
{
fn get_gateway(
execution_path: ExecutionPath,
) -> Box<
dyn payment_gateway::PaymentGateway<
SessionState,
RCD,
Self,
types::PaymentsSessionData,
types::PaymentsResponseData,
RouterGatewayContext,
>,
> {
match execution_path {
ExecutionPath::Direct => Box::new(payment_gateway::DirectGateway),
ExecutionPath::UnifiedConnectorService
| ExecutionPath::ShadowUnifiedConnectorService => Box::new(Self),
}
}
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/payments/operations/payment_confirm.rs | crates/router/src/core/payments/operations/payment_confirm.rs | use std::marker::PhantomData;
#[cfg(feature = "v1")]
use api_models::payment_methods::PaymentMethodsData;
use api_models::{
admin::ExtendedCardInfoConfig,
enums::FrmSuggestion,
payments::{ConnectorMandateReferenceId, ExtendedCardInfo, GetAddressFromPaymentMethodData},
};
use async_trait::async_trait;
use common_utils::ext_traits::{AsyncExt, Encode, StringExt, ValueExt};
use diesel_models::payment_attempt::ConnectorMandateReferenceId as DieselConnectorMandateReferenceId;
use error_stack::{report, ResultExt};
use futures::FutureExt;
#[cfg(feature = "v1")]
use hyperswitch_domain_models::payments::payment_intent::PaymentIntentUpdateFields;
use hyperswitch_domain_models::router_request_types::unified_authentication_service;
use masking::{ExposeInterface, PeekInterface};
use router_derive::PaymentOperation;
use router_env::{instrument, logger, tracing};
use tracing_futures::Instrument;
use super::{BoxedOperation, Domain, GetTracker, Operation, UpdateTracker, ValidateRequest};
#[cfg(feature = "v1")]
use crate::{
consts,
core::payment_methods::cards::create_encrypted_data,
events::audit_events::{AuditEvent, AuditEventType},
};
use crate::{
core::{
authentication,
blocklist::utils as blocklist_utils,
card_testing_guard::utils as card_testing_guard_utils,
errors::{self, CustomResult, RouterResult, StorageErrorExt},
mandate::helpers as m_helpers,
metrics,
payments::{
self, helpers, operations,
operations::payment_confirm::unified_authentication_service::ThreeDsMetaData,
populate_surcharge_details, CustomerDetails, PaymentAddress, PaymentData,
},
three_ds_decision_rule,
unified_authentication_service::{
self as uas_utils,
types::{ClickToPay, UnifiedAuthenticationService},
},
utils as core_utils,
},
routes::{app::ReqState, SessionState},
services,
types::{
self,
api::{self, ConnectorCallType, PaymentIdTypeExt},
domain::{self},
storage::{self, enums as storage_enums},
transformers::{ForeignFrom, ForeignInto},
},
utils::{self, OptionExt},
};
#[derive(Debug, Clone, Copy, PaymentOperation)]
#[operation(operations = "all", flow = "authorize")]
pub struct PaymentConfirm;
type PaymentConfirmOperation<'b, F> = BoxedOperation<'b, F, api::PaymentsRequest, PaymentData<F>>;
#[async_trait]
impl<F: Send + Clone + Sync> GetTracker<F, PaymentData<F>, api::PaymentsRequest>
for PaymentConfirm
{
#[instrument(skip_all)]
async fn get_trackers<'a>(
&'a self,
state: &'a SessionState,
payment_id: &api::PaymentIdType,
request: &api::PaymentsRequest,
platform: &domain::Platform,
auth_flow: services::AuthFlow,
header_payload: &hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<operations::GetTrackerResponse<'a, F, api::PaymentsRequest, PaymentData<F>>>
{
let merchant_id = platform.get_processor().get_account().get_id();
let storage_scheme = platform.get_processor().get_account().storage_scheme;
let (currency, amount);
let payment_id = payment_id
.get_payment_intent_id()
.change_context(errors::ApiErrorResponse::PaymentNotFound)?;
// Stage 1
let store = &*state.store;
let m_merchant_id = merchant_id.clone();
// Parallel calls - level 0
let mut payment_intent = store
.find_payment_intent_by_payment_id_merchant_id(
&payment_id,
&m_merchant_id,
platform.get_processor().get_key_store(),
storage_scheme,
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
// TODO (#7195): Add platform merchant account validation once client_secret auth is solved
if let Some(order_details) = &request.order_details {
helpers::validate_order_details_amount(
order_details.to_owned(),
payment_intent.amount,
false,
)?;
}
helpers::validate_customer_access(&payment_intent, auth_flow, request)?;
if [
Some(common_enums::PaymentSource::Webhook),
Some(common_enums::PaymentSource::ExternalAuthenticator),
]
.contains(&header_payload.payment_confirm_source)
{
helpers::validate_payment_status_against_not_allowed_statuses(
payment_intent.status,
&[
storage_enums::IntentStatus::Cancelled,
storage_enums::IntentStatus::Succeeded,
storage_enums::IntentStatus::Processing,
storage_enums::IntentStatus::RequiresCapture,
storage_enums::IntentStatus::RequiresMerchantAction,
],
"confirm",
)?;
} else {
helpers::validate_payment_status_against_not_allowed_statuses(
payment_intent.status,
&[
storage_enums::IntentStatus::Cancelled,
storage_enums::IntentStatus::Succeeded,
storage_enums::IntentStatus::Processing,
storage_enums::IntentStatus::RequiresCapture,
storage_enums::IntentStatus::RequiresMerchantAction,
storage_enums::IntentStatus::RequiresCustomerAction,
],
"confirm",
)?;
}
helpers::authenticate_client_secret(request.client_secret.as_ref(), &payment_intent)?;
let customer_details = helpers::get_customer_details_from_request(request);
// Stage 2
let attempt_id = payment_intent.active_attempt.get_id();
let profile_id = payment_intent
.profile_id
.clone()
.get_required_value("profile_id")
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("'profile_id' not set in payment intent")?;
let store = state.store.clone();
let key_store_clone = platform.get_processor().get_key_store().clone();
let business_profile_fut = tokio::spawn(
async move {
store
.find_business_profile_by_profile_id(&key_store_clone, &profile_id)
.map(|business_profile_result| {
business_profile_result.to_not_found_response(
errors::ApiErrorResponse::ProfileNotFound {
id: profile_id.get_string_repr().to_owned(),
},
)
})
.await
}
.in_current_span(),
);
let store = state.store.clone();
let m_payment_id = payment_intent.payment_id.clone();
let m_merchant_id = merchant_id.clone();
let merchant_key_store = platform.get_processor().get_key_store().clone();
let payment_attempt_fut = tokio::spawn(
async move {
store
.find_payment_attempt_by_payment_id_merchant_id_attempt_id(
&m_payment_id,
&m_merchant_id,
attempt_id.as_str(),
storage_scheme,
&merchant_key_store,
)
.map(|x| x.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound))
.await
}
.in_current_span(),
);
let m_merchant_id = merchant_id.clone();
let m_request_shipping = request.shipping.clone();
let m_payment_intent_shipping_address_id = payment_intent.shipping_address_id.clone();
let m_payment_intent_payment_id = payment_intent.payment_id.clone();
let m_customer_details_customer_id = customer_details.customer_id.clone();
let m_payment_intent_customer_id = payment_intent.customer_id.clone();
let m_key_store = platform.get_processor().get_key_store().clone();
let session_state = state.clone();
let shipping_address_fut = tokio::spawn(
async move {
helpers::create_or_update_address_for_payment_by_request(
&session_state,
m_request_shipping.as_ref(),
m_payment_intent_shipping_address_id.as_deref(),
&m_merchant_id,
m_payment_intent_customer_id
.as_ref()
.or(m_customer_details_customer_id.as_ref()),
&m_key_store,
&m_payment_intent_payment_id,
storage_scheme,
)
.await
}
.in_current_span(),
);
let m_merchant_id = merchant_id.clone();
let m_request_billing = request.billing.clone();
let m_customer_details_customer_id = customer_details.customer_id.clone();
let m_payment_intent_customer_id = payment_intent.customer_id.clone();
let m_payment_intent_billing_address_id = payment_intent.billing_address_id.clone();
let m_payment_intent_payment_id = payment_intent.payment_id.clone();
let m_key_store = platform.get_processor().get_key_store().clone();
let session_state = state.clone();
let billing_address_fut = tokio::spawn(
async move {
helpers::create_or_update_address_for_payment_by_request(
&session_state,
m_request_billing.as_ref(),
m_payment_intent_billing_address_id.as_deref(),
&m_merchant_id,
m_payment_intent_customer_id
.as_ref()
.or(m_customer_details_customer_id.as_ref()),
&m_key_store,
&m_payment_intent_payment_id,
storage_scheme,
)
.await
}
.in_current_span(),
);
let store = state.clone().store;
let m_request_merchant_connector_details = request.merchant_connector_details.clone();
let m_processor = platform.get_processor().clone();
let config_update_fut = tokio::spawn(
async move {
m_request_merchant_connector_details
.async_map(|mcd| async {
helpers::insert_merchant_connector_creds_to_config(
store.as_ref(),
&m_processor,
mcd,
)
.await
})
.map(|x| x.transpose())
.await
}
.in_current_span(),
);
// Based on whether a retry can be performed or not, fetch relevant entities
let (mut payment_attempt, shipping_address, billing_address, business_profile) =
match payment_intent.status {
api_models::enums::IntentStatus::RequiresCustomerAction
| api_models::enums::IntentStatus::RequiresMerchantAction
| api_models::enums::IntentStatus::RequiresPaymentMethod
| api_models::enums::IntentStatus::RequiresConfirmation => {
// Normal payment
// Parallel calls - level 1
let (payment_attempt, shipping_address, billing_address, business_profile, _) =
tokio::try_join!(
utils::flatten_join_error(payment_attempt_fut),
utils::flatten_join_error(shipping_address_fut),
utils::flatten_join_error(billing_address_fut),
utils::flatten_join_error(business_profile_fut),
utils::flatten_join_error(config_update_fut)
)?;
(
payment_attempt,
shipping_address,
billing_address,
business_profile,
)
}
_ => {
// Retry payment
let (
mut payment_attempt,
shipping_address,
billing_address,
business_profile,
_,
) = tokio::try_join!(
utils::flatten_join_error(payment_attempt_fut),
utils::flatten_join_error(shipping_address_fut),
utils::flatten_join_error(billing_address_fut),
utils::flatten_join_error(business_profile_fut),
utils::flatten_join_error(config_update_fut)
)?;
let attempt_type = helpers::get_attempt_type(
&payment_intent,
&payment_attempt,
business_profile.is_manual_retry_enabled,
"confirm",
)?;
// 3
(payment_intent, payment_attempt) = attempt_type
.modify_payment_intent_and_payment_attempt(
request,
payment_intent,
payment_attempt,
state,
platform.get_processor().get_key_store(),
storage_scheme,
)
.await?;
(
payment_attempt,
shipping_address,
billing_address,
business_profile,
)
}
};
payment_intent.order_details = request
.get_order_details_as_value()
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed to convert order details to value")?
.or(payment_intent.order_details);
payment_intent.setup_future_usage = request
.setup_future_usage
.or(payment_intent.setup_future_usage);
payment_intent.psd2_sca_exemption_type = request
.psd2_sca_exemption_type
.or(payment_intent.psd2_sca_exemption_type);
let browser_info = request
.browser_info
.clone()
.or(payment_attempt.browser_info)
.as_ref()
.map(Encode::encode_to_value)
.transpose()
.change_context(errors::ApiErrorResponse::InvalidDataValue {
field_name: "browser_info",
})?;
let customer_acceptance = request.customer_acceptance.clone().or(payment_attempt
.customer_acceptance
.clone()
.map(|customer_acceptance| {
customer_acceptance
.expose()
.parse_value("CustomerAcceptance")
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed while deserializing customer_acceptance")
})
.transpose()?);
let recurring_details = request.recurring_details.clone();
helpers::validate_card_data(
request
.payment_method_data
.as_ref()
.and_then(|pmd| pmd.payment_method_data.clone()),
)?;
payment_attempt.browser_info = browser_info;
payment_attempt.payment_experience = request
.payment_experience
.or(payment_attempt.payment_experience);
payment_attempt.capture_method = request.capture_method.or(payment_attempt.capture_method);
payment_attempt.customer_acceptance = request
.customer_acceptance
.clone()
.map(|customer_acceptance| customer_acceptance.encode_to_value())
.transpose()
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed while encoding customer_acceptance to value")?
.map(masking::Secret::new)
.or(payment_attempt.customer_acceptance);
currency = payment_attempt.currency.get_required_value("currency")?;
amount = payment_attempt.get_total_amount().into();
helpers::validate_customer_id_mandatory_cases(
request.setup_future_usage.is_some(),
payment_intent
.customer_id
.as_ref()
.or(customer_details.customer_id.as_ref()),
)?;
let creds_identifier = request
.merchant_connector_details
.as_ref()
.map(|mcd| mcd.creds_identifier.to_owned());
payment_intent.shipping_address_id =
shipping_address.as_ref().map(|i| i.address_id.clone());
payment_intent.billing_address_id = billing_address.as_ref().map(|i| i.address_id.clone());
payment_intent.return_url = request
.return_url
.as_ref()
.map(|a| a.to_string())
.or(payment_intent.return_url);
payment_intent.allowed_payment_method_types = request
.get_allowed_payment_method_types_as_value()
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Error converting allowed_payment_types to Value")?
.or(payment_intent.allowed_payment_method_types);
payment_intent.connector_metadata = request
.get_connector_metadata_as_value()
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Error converting connector_metadata to Value")?
.or(payment_intent.connector_metadata);
payment_intent.feature_metadata = request
.get_feature_metadata_as_value()
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Error converting feature_metadata to Value")?
.or(payment_intent.feature_metadata);
payment_intent.metadata = request.metadata.clone().or(payment_intent.metadata);
payment_intent.frm_metadata = request.frm_metadata.clone().or(payment_intent.frm_metadata);
payment_intent.request_incremental_authorization = request
.request_incremental_authorization
.map(|request_incremental_authorization| {
core_utils::get_request_incremental_authorization_value(
Some(request_incremental_authorization),
payment_attempt.capture_method,
)
})
.unwrap_or(Ok(payment_intent.request_incremental_authorization))?;
payment_intent.enable_partial_authorization = request
.enable_partial_authorization
.or(payment_intent.enable_partial_authorization);
payment_attempt.business_sub_label = request
.business_sub_label
.clone()
.or(payment_attempt.business_sub_label);
let n_request_payment_method_data = request
.payment_method_data
.as_ref()
.and_then(|pmd| pmd.payment_method_data.clone());
let store = state.clone().store;
let profile_id = payment_intent
.profile_id
.clone()
.get_required_value("profile_id")
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("'profile_id' not set in payment intent")?;
let additional_pm_data_fut = tokio::spawn(
async move {
Ok(n_request_payment_method_data
.async_map(|payment_method_data| async move {
helpers::get_additional_payment_data(
&payment_method_data.into(),
store.as_ref(),
&profile_id,
None,
)
.await
})
.await)
}
.in_current_span(),
);
let n_payment_method_billing_address_id =
payment_attempt.payment_method_billing_address_id.clone();
let n_request_payment_method_billing_address = request
.payment_method_data
.as_ref()
.and_then(|pmd| pmd.billing.clone());
let m_payment_intent_customer_id = payment_intent.customer_id.clone();
let m_payment_intent_payment_id = payment_intent.payment_id.clone();
let m_key_store = platform.get_processor().get_key_store().clone();
let m_customer_details_customer_id = customer_details.customer_id.clone();
let m_merchant_id = merchant_id.clone();
let session_state = state.clone();
let payment_method_billing_future = tokio::spawn(
async move {
helpers::create_or_update_address_for_payment_by_request(
&session_state,
n_request_payment_method_billing_address.as_ref(),
n_payment_method_billing_address_id.as_deref(),
&m_merchant_id,
m_payment_intent_customer_id
.as_ref()
.or(m_customer_details_customer_id.as_ref()),
&m_key_store,
&m_payment_intent_payment_id,
storage_scheme,
)
.await
}
.in_current_span(),
);
let mandate_type = m_helpers::get_mandate_type(
request.mandate_data.clone(),
request.off_session,
payment_intent.setup_future_usage,
request.customer_acceptance.clone(),
request.payment_token.clone(),
payment_attempt.payment_method.or(request.payment_method),
)
.change_context(errors::ApiErrorResponse::MandateValidationFailed {
reason: "Expected one out of recurring_details and mandate_data but got both".into(),
})?;
let m_state = state.clone();
let m_mandate_type = mandate_type;
let m_platform = platform.clone();
let m_request = request.clone();
let payment_intent_customer_id = payment_intent.customer_id.clone();
let mandate_details_fut = tokio::spawn(
async move {
Box::pin(helpers::get_token_pm_type_mandate_details(
&m_state,
&m_request,
m_mandate_type,
&m_platform,
None,
payment_intent_customer_id.as_ref(),
))
.await
}
.in_current_span(),
);
// Parallel calls - level 2
let (mandate_details, additional_pm_info, payment_method_billing) = tokio::try_join!(
utils::flatten_join_error(mandate_details_fut),
utils::flatten_join_error(additional_pm_data_fut),
utils::flatten_join_error(payment_method_billing_future),
)?;
let additional_pm_data = additional_pm_info.transpose()?.flatten();
let m_helpers::MandateGenericData {
token,
payment_method,
payment_method_type,
mandate_data,
recurring_mandate_payment_data,
mandate_connector,
payment_method_info,
} = mandate_details;
let token = token.or_else(|| payment_attempt.payment_token.clone());
helpers::validate_pm_or_token_given(
&request.payment_method,
&request
.payment_method_data
.as_ref()
.and_then(|pmd| pmd.payment_method_data.clone()),
&request.payment_method_type,
&mandate_type,
&token,
&request.ctp_service_details,
)?;
let (token_data, payment_method_info) = if let Some(token) = token.clone() {
let token_data = helpers::retrieve_payment_token_data(
state,
token,
payment_method.or(payment_attempt.payment_method),
)
.await?;
let payment_method_info = helpers::retrieve_payment_method_from_db_with_token_data(
state,
platform.get_processor().get_key_store(),
&token_data,
storage_scheme,
)
.await?;
(Some(token_data), payment_method_info)
} else {
(None, payment_method_info)
};
let additional_pm_data_from_locker = if let Some(ref pm) = payment_method_info {
let card_detail_from_locker: Option<api::CardDetailFromLocker> = pm
.payment_method_data
.clone()
.map(|x| x.into_inner().expose())
.and_then(|v| {
v.parse_value("PaymentMethodsData")
.map_err(|err| {
router_env::logger::info!(
"PaymentMethodsData deserialization failed: {:?}",
err
)
})
.ok()
})
.and_then(|pmd| match pmd {
PaymentMethodsData::Card(crd) => Some(api::CardDetailFromLocker::from(crd)),
_ => None,
});
card_detail_from_locker.map(|card_details| {
let additional_data = card_details.into();
api_models::payments::AdditionalPaymentData::Card(Box::new(additional_data))
})
} else {
None
};
// Only set `payment_attempt.payment_method_data` if `additional_pm_data_from_locker` is not None
if let Some(additional_pm_data) = additional_pm_data_from_locker.as_ref() {
payment_attempt.payment_method_data = Some(
Encode::encode_to_value(additional_pm_data)
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed to encode additional pm data")?,
);
}
payment_attempt.payment_method = payment_method.or(payment_attempt.payment_method);
let payment_method_type = Option::<api_models::enums::PaymentMethodType>::foreign_from((
payment_method_type,
additional_pm_data.as_ref(),
payment_method,
));
payment_attempt.payment_method_type = payment_method_type
.or(payment_attempt.payment_method_type)
.or(payment_method_info
.as_ref()
.and_then(|pm_info| pm_info.get_payment_method_subtype()));
// The operation merges mandate data from both request and payment_attempt
let setup_mandate = mandate_data.map(|mut sm| {
sm.mandate_type = payment_attempt.mandate_details.clone().or(sm.mandate_type);
sm.update_mandate_id = payment_attempt
.mandate_data
.clone()
.and_then(|mandate| mandate.update_mandate_id)
.or(sm.update_mandate_id);
sm
});
let mandate_details_present =
payment_attempt.mandate_details.is_some() || request.mandate_data.is_some();
helpers::validate_mandate_data_and_future_usage(
payment_intent.setup_future_usage,
mandate_details_present,
)?;
let payment_method_data_after_card_bin_call = request
.payment_method_data
.as_ref()
.and_then(|request_payment_method_data| {
request_payment_method_data.payment_method_data.as_ref()
})
.zip(additional_pm_data)
.map(|(payment_method_data, additional_payment_data)| {
payment_method_data.apply_additional_payment_data(additional_payment_data)
})
.transpose()
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Card cobadge check failed due to an invalid card network regex")?;
payment_attempt.payment_method_billing_address_id = payment_method_billing
.as_ref()
.map(|payment_method_billing| payment_method_billing.address_id.clone());
let address = PaymentAddress::new(
shipping_address.as_ref().map(From::from),
billing_address.as_ref().map(From::from),
payment_method_billing.as_ref().map(From::from),
business_profile.use_billing_as_payment_method_billing,
);
let payment_method_data_billing = request
.payment_method_data
.as_ref()
.and_then(|pmd| pmd.payment_method_data.as_ref())
.and_then(|payment_method_data_billing| {
payment_method_data_billing.get_billing_address()
})
.map(From::from);
let unified_address =
address.unify_with_payment_method_data_billing(payment_method_data_billing);
// If processor_payment_token is passed in request then populating the same in PaymentData
let mandate_id = request
.recurring_details
.as_ref()
.and_then(|recurring_details| match recurring_details {
api_models::mandates::RecurringDetails::ProcessorPaymentToken(token) => {
payment_intent.is_payment_processor_token_flow = Some(true);
Some(api_models::payments::MandateIds {
mandate_id: None,
mandate_reference_id: Some(
api_models::payments::MandateReferenceId::ConnectorMandateId(
ConnectorMandateReferenceId::new(
Some(token.processor_payment_token.clone()), // connector_mandate_id
None, // payment_method_id
None, // update_history
None, // mandate_metadata
None, // connector_mandate_request_reference_id
None,
),
),
),
})
}
_ => None,
});
let pmt_order_tax_amount = payment_intent.tax_details.clone().and_then(|tax| {
if tax.payment_method_type.clone().map(|a| a.pmt) == payment_attempt.payment_method_type
{
tax.payment_method_type.map(|a| a.order_tax_amount)
} else {
None
}
});
let order_tax_amount = pmt_order_tax_amount.or_else(|| {
payment_intent
.tax_details
.clone()
.and_then(|tax| tax.default.map(|a| a.order_tax_amount))
});
payment_attempt
.net_amount
.set_order_tax_amount(order_tax_amount);
payment_attempt.connector_mandate_detail = Some(
DieselConnectorMandateReferenceId::foreign_from(ConnectorMandateReferenceId::new(
None,
None,
None, // update_history
None, // mandate_metadata
Some(common_utils::generate_id_with_len(
consts::CONNECTOR_MANDATE_REQUEST_REFERENCE_ID_LENGTH,
)), // connector_mandate_request_reference_id
None,
)),
);
let payment_data = PaymentData {
flow: PhantomData,
payment_intent,
payment_attempt,
currency,
amount,
email: request.email.clone(),
mandate_id: mandate_id.clone(),
mandate_connector,
setup_mandate,
customer_acceptance,
token,
address: unified_address,
token_data,
confirm: request.confirm,
payment_method_data: payment_method_data_after_card_bin_call.map(Into::into),
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | true |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/payments/operations/payment_get.rs | crates/router/src/core/payments/operations/payment_get.rs | use api_models::{enums::FrmSuggestion, payments::PaymentsRetrieveRequest};
use async_trait::async_trait;
use common_utils::ext_traits::AsyncExt;
use error_stack::ResultExt;
use hyperswitch_domain_models::payments::PaymentStatusData;
use router_env::{instrument, tracing};
use super::{Domain, GetTracker, Operation, UpdateTracker, ValidateRequest};
use crate::{
core::{
errors::{self, CustomResult, RouterResult, StorageErrorExt},
payments::{
helpers,
operations::{self, ValidateStatusForOperation},
},
},
routes::{app::ReqState, SessionState},
types::{
api::{self, ConnectorCallType},
domain::{self},
storage::{self, enums as storage_enums},
},
utils::OptionExt,
};
#[derive(Debug, Clone, Copy)]
pub struct PaymentGet;
impl ValidateStatusForOperation for PaymentGet {
/// Validate if the current operation can be performed on the current status of the payment intent
fn validate_status_for_operation(
&self,
intent_status: common_enums::IntentStatus,
) -> Result<(), errors::ApiErrorResponse> {
match intent_status {
common_enums::IntentStatus::RequiresCapture
| common_enums::IntentStatus::PartiallyAuthorizedAndRequiresCapture
| common_enums::IntentStatus::RequiresCustomerAction
| common_enums::IntentStatus::RequiresMerchantAction
| common_enums::IntentStatus::Processing
| common_enums::IntentStatus::PartiallyCapturedAndProcessing
| common_enums::IntentStatus::Succeeded
| common_enums::IntentStatus::Failed
| common_enums::IntentStatus::PartiallyCapturedAndCapturable
| common_enums::IntentStatus::PartiallyCaptured
| common_enums::IntentStatus::Cancelled
| common_enums::IntentStatus::CancelledPostCapture
| common_enums::IntentStatus::Conflicted
| common_enums::IntentStatus::Expired => Ok(()),
// These statuses are not valid for this operation
common_enums::IntentStatus::RequiresConfirmation
| common_enums::IntentStatus::RequiresPaymentMethod => {
Err(errors::ApiErrorResponse::PaymentUnexpectedState {
current_flow: format!("{self:?}"),
field_name: "status".to_string(),
current_value: intent_status.to_string(),
states: [
common_enums::IntentStatus::RequiresCapture,
common_enums::IntentStatus::PartiallyAuthorizedAndRequiresCapture,
common_enums::IntentStatus::RequiresCustomerAction,
common_enums::IntentStatus::RequiresMerchantAction,
common_enums::IntentStatus::Processing,
common_enums::IntentStatus::Succeeded,
common_enums::IntentStatus::Failed,
common_enums::IntentStatus::PartiallyCapturedAndCapturable,
common_enums::IntentStatus::PartiallyCaptured,
common_enums::IntentStatus::Cancelled,
]
.map(|enum_value| enum_value.to_string())
.join(", "),
})
}
}
}
}
type BoxedConfirmOperation<'b, F> =
super::BoxedOperation<'b, F, PaymentsRetrieveRequest, PaymentStatusData<F>>;
// TODO: change the macro to include changes for v2
// TODO: PaymentData in the macro should be an input
impl<F: Send + Clone + Sync> Operation<F, PaymentsRetrieveRequest> for &PaymentGet {
type Data = PaymentStatusData<F>;
fn to_validate_request(
&self,
) -> RouterResult<&(dyn ValidateRequest<F, PaymentsRetrieveRequest, Self::Data> + Send + Sync)>
{
Ok(*self)
}
fn to_get_tracker(
&self,
) -> RouterResult<&(dyn GetTracker<F, Self::Data, PaymentsRetrieveRequest> + Send + Sync)> {
Ok(*self)
}
fn to_domain(&self) -> RouterResult<&(dyn Domain<F, PaymentsRetrieveRequest, Self::Data>)> {
Ok(*self)
}
fn to_update_tracker(
&self,
) -> RouterResult<&(dyn UpdateTracker<F, Self::Data, PaymentsRetrieveRequest> + Send + Sync)>
{
Ok(*self)
}
}
#[automatically_derived]
impl<F: Send + Clone + Sync> Operation<F, PaymentsRetrieveRequest> for PaymentGet {
type Data = PaymentStatusData<F>;
fn to_validate_request(
&self,
) -> RouterResult<&(dyn ValidateRequest<F, PaymentsRetrieveRequest, Self::Data> + Send + Sync)>
{
Ok(self)
}
fn to_get_tracker(
&self,
) -> RouterResult<&(dyn GetTracker<F, Self::Data, PaymentsRetrieveRequest> + Send + Sync)> {
Ok(self)
}
fn to_domain(&self) -> RouterResult<&dyn Domain<F, PaymentsRetrieveRequest, Self::Data>> {
Ok(self)
}
fn to_update_tracker(
&self,
) -> RouterResult<&(dyn UpdateTracker<F, Self::Data, PaymentsRetrieveRequest> + Send + Sync)>
{
Ok(self)
}
}
impl<F: Send + Clone + Sync> ValidateRequest<F, PaymentsRetrieveRequest, PaymentStatusData<F>>
for PaymentGet
{
#[instrument(skip_all)]
fn validate_request<'a, 'b>(
&'b self,
_request: &PaymentsRetrieveRequest,
platform: &'a domain::Platform,
) -> RouterResult<operations::ValidateResult> {
let validate_result = operations::ValidateResult {
merchant_id: platform.get_processor().get_account().get_id().to_owned(),
storage_scheme: platform.get_processor().get_account().storage_scheme,
requeue: false,
};
Ok(validate_result)
}
}
#[async_trait]
impl<F: Send + Clone + Sync> GetTracker<F, PaymentStatusData<F>, PaymentsRetrieveRequest>
for PaymentGet
{
#[instrument(skip_all)]
async fn get_trackers<'a>(
&'a self,
state: &'a SessionState,
payment_id: &common_utils::id_type::GlobalPaymentId,
request: &PaymentsRetrieveRequest,
platform: &domain::Platform,
_profile: &domain::Profile,
_header_payload: &hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<operations::GetTrackerResponse<PaymentStatusData<F>>> {
let db = &*state.store;
let storage_scheme = platform.get_processor().get_account().storage_scheme;
let payment_intent = db
.find_payment_intent_by_id(
payment_id,
platform.get_processor().get_key_store(),
storage_scheme,
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
self.validate_status_for_operation(payment_intent.status)?;
let active_attempt_id = payment_intent.active_attempt_id.as_ref().ok_or_else(|| {
errors::ApiErrorResponse::MissingRequiredField {
field_name: ("active_attempt_id"),
}
})?;
let mut payment_attempt = db
.find_payment_attempt_by_id(
platform.get_processor().get_key_store(),
active_attempt_id,
storage_scheme,
)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Could not find payment attempt given the attempt id")?;
payment_attempt.encoded_data = request
.param
.as_ref()
.map(|val| masking::Secret::new(val.clone()));
let should_sync_with_connector =
request.force_sync && payment_intent.status.should_force_sync_with_connector();
// We need the address here to send it in the response
let payment_address = hyperswitch_domain_models::payment_address::PaymentAddress::new(
payment_intent
.shipping_address
.clone()
.map(|address| address.into_inner()),
payment_intent
.billing_address
.clone()
.map(|address| address.into_inner()),
payment_attempt
.payment_method_billing_address
.clone()
.map(|address| address.into_inner()),
Some(true),
);
let attempts = match request.expand_attempts {
true => payment_intent
.active_attempt_id
.as_ref()
.async_map(|active_attempt| async {
db.find_payment_attempts_by_payment_intent_id(
payment_id,
platform.get_processor().get_key_store(),
storage_scheme,
)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Could not find payment attempts for the given the intent id")
})
.await
.transpose()?,
false => None,
};
let merchant_connector_details = request.merchant_connector_details.clone();
let payment_data = PaymentStatusData {
flow: std::marker::PhantomData,
payment_intent,
payment_attempt,
payment_address,
attempts,
should_sync_with_connector,
merchant_connector_details,
};
let get_trackers_response = operations::GetTrackerResponse { payment_data };
Ok(get_trackers_response)
}
}
#[async_trait]
impl<F: Clone + Send + Sync> Domain<F, PaymentsRetrieveRequest, PaymentStatusData<F>>
for PaymentGet
{
async fn get_customer_details<'a>(
&'a self,
state: &SessionState,
payment_data: &mut PaymentStatusData<F>,
merchant_key_store: &domain::MerchantKeyStore,
storage_scheme: storage_enums::MerchantStorageScheme,
) -> CustomResult<(BoxedConfirmOperation<'a, F>, Option<domain::Customer>), errors::StorageError>
{
match payment_data.payment_intent.customer_id.clone() {
Some(id) => {
let customer = state
.store
.find_customer_by_global_id(&id, merchant_key_store, storage_scheme)
.await?;
Ok((Box::new(self), Some(customer)))
}
None => Ok((Box::new(self), None)),
}
}
#[instrument(skip_all)]
async fn make_pm_data<'a>(
&'a self,
_state: &'a SessionState,
_payment_data: &mut PaymentStatusData<F>,
_storage_scheme: storage_enums::MerchantStorageScheme,
_key_store: &domain::MerchantKeyStore,
_customer: &Option<domain::Customer>,
_business_profile: &domain::Profile,
_should_retry_with_pan: bool,
) -> RouterResult<(
BoxedConfirmOperation<'a, F>,
Option<domain::PaymentMethodData>,
Option<String>,
)> {
Ok((Box::new(self), None, None))
}
#[instrument(skip_all)]
async fn perform_routing<'a>(
&'a self,
_platform: &domain::Platform,
_business_profile: &domain::Profile,
state: &SessionState,
// TODO: do not take the whole payment data here
payment_data: &mut PaymentStatusData<F>,
) -> CustomResult<ConnectorCallType, errors::ApiErrorResponse> {
let payment_attempt = &payment_data.payment_attempt;
if payment_data.should_sync_with_connector {
let connector = payment_attempt
.connector
.as_ref()
.get_required_value("connector")
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Connector is none when constructing response")?;
let merchant_connector_id = payment_attempt
.merchant_connector_id
.as_ref()
.get_required_value("merchant_connector_id")
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Merchant connector id is none when constructing response")?;
let connector_data = api::ConnectorData::get_connector_by_name(
&state.conf.connectors,
connector,
api::GetToken::Connector,
Some(merchant_connector_id.to_owned()),
)
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Invalid connector name received")?;
Ok(ConnectorCallType::PreDetermined(
api::ConnectorRoutingData::from(connector_data),
))
} else {
Ok(ConnectorCallType::Skip)
}
}
#[cfg(feature = "v2")]
async fn get_connector_from_request<'a>(
&'a self,
state: &SessionState,
request: &PaymentsRetrieveRequest,
payment_data: &mut PaymentStatusData<F>,
) -> CustomResult<api::ConnectorData, errors::ApiErrorResponse> {
use crate::core::payments::OperationSessionSetters;
let connector_data = helpers::get_connector_data_from_request(
state,
request.merchant_connector_details.clone(),
)
.await?;
payment_data
.set_connector_in_payment_attempt(Some(connector_data.connector_name.to_string()));
Ok(connector_data)
}
}
#[async_trait]
impl<F: Clone + Sync> UpdateTracker<F, PaymentStatusData<F>, PaymentsRetrieveRequest>
for PaymentGet
{
#[instrument(skip_all)]
async fn update_trackers<'b>(
&'b self,
_state: &'b SessionState,
_req_state: ReqState,
_processor: &domain::Processor,
payment_data: PaymentStatusData<F>,
_customer: Option<domain::Customer>,
_frm_suggestion: Option<FrmSuggestion>,
_header_payload: hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<(BoxedConfirmOperation<'b, F>, PaymentStatusData<F>)>
where
F: 'b + Send,
{
Ok((Box::new(self), payment_data))
}
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/payments/operations/payment_complete_authorize.rs | crates/router/src/core/payments/operations/payment_complete_authorize.rs | use std::marker::PhantomData;
use api_models::enums::FrmSuggestion;
use async_trait::async_trait;
use error_stack::{report, ResultExt};
use router_derive::PaymentOperation;
use router_env::{instrument, tracing};
use super::{BoxedOperation, Domain, GetTracker, Operation, UpdateTracker, ValidateRequest};
use crate::{
core::{
errors::{self, CustomResult, RouterResult, StorageErrorExt},
mandate::helpers as m_helpers,
payments::{self, helpers, operations, CustomerDetails, PaymentAddress, PaymentData},
},
events::audit_events::{AuditEvent, AuditEventType},
routes::{app::ReqState, SessionState},
services,
types::{
api::{self, CustomerAcceptance, PaymentIdTypeExt},
domain,
storage::{self, enums as storage_enums},
},
utils::{self, OptionExt},
};
#[derive(Debug, Clone, Copy, PaymentOperation)]
#[operation(operations = "all", flow = "authorize")]
pub struct CompleteAuthorize;
type CompleteAuthorizeOperation<'b, F> =
BoxedOperation<'b, F, api::PaymentsRequest, PaymentData<F>>;
#[async_trait]
impl<F: Send + Clone + Sync> GetTracker<F, PaymentData<F>, api::PaymentsRequest>
for CompleteAuthorize
{
#[instrument(skip_all)]
async fn get_trackers<'a>(
&'a self,
state: &'a SessionState,
payment_id: &api::PaymentIdType,
request: &api::PaymentsRequest,
platform: &domain::Platform,
_auth_flow: services::AuthFlow,
_header_payload: &hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<operations::GetTrackerResponse<'a, F, api::PaymentsRequest, PaymentData<F>>>
{
let db = &*state.store;
let merchant_id = platform.get_processor().get_account().get_id();
let storage_scheme = platform.get_processor().get_account().storage_scheme;
let (mut payment_intent, mut payment_attempt, currency, amount);
let payment_id = payment_id
.get_payment_intent_id()
.change_context(errors::ApiErrorResponse::PaymentNotFound)?;
payment_intent = db
.find_payment_intent_by_payment_id_merchant_id(
&payment_id,
merchant_id,
platform.get_processor().get_key_store(),
storage_scheme,
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
// TODO (#7195): Add platform merchant account validation once client_secret auth is solved
payment_intent.setup_future_usage = request
.setup_future_usage
.or(payment_intent.setup_future_usage);
helpers::authenticate_client_secret(request.client_secret.as_ref(), &payment_intent)?;
helpers::validate_payment_status_against_not_allowed_statuses(
payment_intent.status,
&[
storage_enums::IntentStatus::Failed,
storage_enums::IntentStatus::Succeeded,
],
"confirm",
)?;
let browser_info = request
.browser_info
.clone()
.as_ref()
.map(utils::Encode::encode_to_value)
.transpose()
.change_context(errors::ApiErrorResponse::InvalidDataValue {
field_name: "browser_info",
})?;
let recurring_details = request.recurring_details.clone();
payment_attempt = db
.find_payment_attempt_by_payment_id_merchant_id_attempt_id(
&payment_intent.payment_id,
merchant_id,
&payment_intent.active_attempt.get_id(),
storage_scheme,
platform.get_processor().get_key_store(),
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
let mandate_type = m_helpers::get_mandate_type(
request.mandate_data.clone(),
request.off_session,
payment_intent.setup_future_usage,
request.customer_acceptance.clone(),
request.payment_token.clone(),
payment_attempt.payment_method,
)
.change_context(errors::ApiErrorResponse::MandateValidationFailed {
reason: "Expected one out of recurring_details and mandate_data but got both".into(),
})?;
let m_helpers::MandateGenericData {
token,
payment_method,
payment_method_type,
mandate_data,
recurring_mandate_payment_data,
mandate_connector,
payment_method_info,
} = Box::pin(helpers::get_token_pm_type_mandate_details(
state,
request,
mandate_type.to_owned(),
platform,
payment_attempt.payment_method_id.clone(),
payment_intent.customer_id.as_ref(),
))
.await?;
let customer_acceptance: Option<CustomerAcceptance> =
request.customer_acceptance.clone().or(payment_method_info
.clone()
.map(|pm| {
pm.customer_acceptance
.parse_value::<CustomerAcceptance>("CustomerAcceptance")
})
.transpose()
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed to deserialize to CustomerAcceptance")?);
let token = token.or_else(|| payment_attempt.payment_token.clone());
if let Some(payment_method) = payment_method {
let should_validate_pm_or_token_given =
//this validation should happen if data was stored in the vault
helpers::should_store_payment_method_data_in_vault(
&state.conf.temp_locker_enable_config,
payment_attempt.connector.clone(),
payment_method,
);
if should_validate_pm_or_token_given {
helpers::validate_pm_or_token_given(
&request.payment_method,
&request
.payment_method_data
.as_ref()
.and_then(|pmd| pmd.payment_method_data.clone()),
&request.payment_method_type,
&mandate_type,
&token,
&request.ctp_service_details,
)?;
}
}
let token_data = if let Some((token, payment_method)) = token
.as_ref()
.zip(payment_method.or(payment_attempt.payment_method))
{
Some(
helpers::retrieve_payment_token_data(state, token.clone(), Some(payment_method))
.await?,
)
} else {
None
};
payment_attempt.payment_method = payment_method.or(payment_attempt.payment_method);
payment_attempt.browser_info = browser_info.or(payment_attempt.browser_info);
payment_attempt.payment_method_type =
payment_method_type.or(payment_attempt.payment_method_type);
payment_attempt.payment_experience = request
.payment_experience
.or(payment_attempt.payment_experience);
currency = payment_attempt.currency.get_required_value("currency")?;
amount = payment_attempt.get_total_amount().into();
let customer_id = payment_intent
.customer_id
.as_ref()
.or(request.customer_id.as_ref())
.cloned();
helpers::validate_customer_id_mandatory_cases(
request.setup_future_usage.is_some(),
customer_id.as_ref(),
)?;
let shipping_address = helpers::create_or_update_address_for_payment_by_request(
state,
request.shipping.as_ref(),
payment_intent.shipping_address_id.clone().as_deref(),
merchant_id,
payment_intent.customer_id.as_ref(),
platform.get_processor().get_key_store(),
&payment_id,
storage_scheme,
)
.await?;
payment_intent.shipping_address_id = shipping_address
.as_ref()
.map(|shipping_address| shipping_address.address_id.clone());
let billing_address = helpers::get_address_by_id(
state,
payment_intent.billing_address_id.clone(),
platform.get_processor().get_key_store(),
&payment_intent.payment_id,
merchant_id,
platform.get_processor().get_account().storage_scheme,
)
.await?;
let payment_method_billing = helpers::get_address_by_id(
state,
payment_attempt.payment_method_billing_address_id.clone(),
platform.get_processor().get_key_store(),
&payment_intent.payment_id,
merchant_id,
platform.get_processor().get_account().storage_scheme,
)
.await?;
let redirect_response = request
.feature_metadata
.as_ref()
.and_then(|fm| fm.redirect_response.clone());
payment_intent.shipping_address_id = shipping_address.clone().map(|i| i.address_id);
payment_intent.billing_address_id = billing_address.clone().map(|i| i.address_id);
payment_intent.return_url = request
.return_url
.as_ref()
.map(|a| a.to_string())
.or(payment_intent.return_url);
payment_intent.allowed_payment_method_types = request
.get_allowed_payment_method_types_as_value()
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Error converting allowed_payment_types to Value")?
.or(payment_intent.allowed_payment_method_types);
payment_intent.connector_metadata = request
.get_connector_metadata_as_value()
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Error converting connector_metadata to Value")?
.or(payment_intent.connector_metadata);
payment_intent.feature_metadata = request
.get_feature_metadata_as_value()
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Error converting feature_metadata to Value")?
.or(payment_intent.feature_metadata);
payment_intent.metadata = request.metadata.clone().or(payment_intent.metadata);
// The operation merges mandate data from both request and payment_attempt
let setup_mandate = mandate_data;
let mandate_details_present =
payment_attempt.mandate_details.is_some() || request.mandate_data.is_some();
helpers::validate_mandate_data_and_future_usage(
payment_intent.setup_future_usage,
mandate_details_present,
)?;
let profile_id = payment_intent
.profile_id
.as_ref()
.get_required_value("profile_id")
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("'profile_id' not set in payment intent")?;
let business_profile = db
.find_business_profile_by_profile_id(
platform.get_processor().get_key_store(),
profile_id,
)
.await
.to_not_found_response(errors::ApiErrorResponse::ProfileNotFound {
id: profile_id.get_string_repr().to_owned(),
})?;
let creds_identifier =
request
.merchant_connector_details
.as_ref()
.map(|merchant_connector_details| {
merchant_connector_details.creds_identifier.to_owned()
});
let payment_data = PaymentData {
flow: PhantomData,
payment_intent,
payment_attempt,
currency,
amount,
email: request.email.clone(),
mandate_id: None,
mandate_connector,
setup_mandate,
customer_acceptance,
token,
token_data,
address: PaymentAddress::new(
shipping_address.as_ref().map(From::from),
billing_address.as_ref().map(From::from),
payment_method_billing.as_ref().map(From::from),
business_profile.use_billing_as_payment_method_billing,
),
confirm: request.confirm,
payment_method_data: request
.payment_method_data
.as_ref()
.and_then(|pmd| pmd.payment_method_data.clone().map(Into::into)),
payment_method_token: None,
payment_method_info,
force_sync: None,
all_keys_required: None,
refunds: vec![],
disputes: vec![],
attempts: None,
sessions_token: vec![],
card_cvc: request.card_cvc.clone(),
creds_identifier,
pm_token: None,
connector_customer_id: None,
recurring_mandate_payment_data,
multiple_capture_data: None,
redirect_response,
surcharge_details: None,
frm_message: None,
payment_link_data: None,
incremental_authorization_details: None,
authorizations: vec![],
authentication: None,
recurring_details,
poll_config: None,
tax_data: None,
session_id: None,
service_details: None,
card_testing_guard_data: None,
vault_operation: None,
threeds_method_comp_ind: request.threeds_method_comp_ind.clone(),
whole_connector_response: None,
is_manual_retry_enabled: None,
is_l2_l3_enabled: business_profile.is_l2_l3_enabled,
external_authentication_data: None,
};
let customer_details = Some(CustomerDetails {
customer_id,
name: request.name.clone(),
email: request.email.clone(),
phone: request.phone.clone(),
phone_country_code: request.phone_country_code.clone(),
tax_registration_id: None,
});
let get_trackers_response = operations::GetTrackerResponse {
operation: Box::new(self),
customer_details,
payment_data,
business_profile,
mandate_type,
};
Ok(get_trackers_response)
}
}
#[async_trait]
impl<F: Clone + Send + Sync> Domain<F, api::PaymentsRequest, PaymentData<F>> for CompleteAuthorize {
#[instrument(skip_all)]
async fn populate_raw_customer_details<'a>(
&'a self,
state: &SessionState,
payment_data: &mut PaymentData<F>,
request: Option<&CustomerDetails>,
processor: &domain::Processor,
) -> CustomResult<(), errors::StorageError> {
helpers::populate_raw_customer_details(state, payment_data, request, processor).await
}
#[instrument(skip_all)]
async fn get_or_create_customer_details<'a>(
&'a self,
state: &SessionState,
payment_data: &mut PaymentData<F>,
request: Option<CustomerDetails>,
provider: &domain::Provider,
) -> CustomResult<
(CompleteAuthorizeOperation<'a, F>, Option<domain::Customer>),
errors::StorageError,
> {
match provider.get_account().merchant_account_type {
common_enums::MerchantAccountType::Standard => {
helpers::create_customer_if_not_exist(
state,
Box::new(self),
payment_data,
request,
provider,
)
.await
}
common_enums::MerchantAccountType::Platform => {
let customer = helpers::get_customer_if_exists(
state,
request.as_ref().and_then(|r| r.customer_id.as_ref()),
payment_data.payment_intent.customer_id.as_ref(),
provider,
)
.await?
.inspect(|cust| {
payment_data.email = payment_data
.email
.clone()
.or_else(|| cust.email.clone().map(Into::into));
});
Ok((Box::new(self), customer))
}
common_enums::MerchantAccountType::Connected => {
Err(errors::StorageError::ValueNotFound(
"Connected merchant cannot be a provider".to_string(),
)
.into())
}
}
}
#[instrument(skip_all)]
async fn make_pm_data<'a>(
&'a self,
state: &'a SessionState,
payment_data: &mut PaymentData<F>,
storage_scheme: storage_enums::MerchantStorageScheme,
merchant_key_store: &domain::MerchantKeyStore,
customer: &Option<domain::Customer>,
business_profile: &domain::Profile,
should_retry_with_pan: bool,
) -> RouterResult<(
CompleteAuthorizeOperation<'a, F>,
Option<domain::PaymentMethodData>,
Option<String>,
)> {
let (op, payment_method_data, pm_id) = Box::pin(helpers::make_pm_data(
Box::new(self),
state,
payment_data,
merchant_key_store,
customer,
storage_scheme,
business_profile,
should_retry_with_pan,
))
.await?;
Ok((op, payment_method_data, pm_id))
}
#[instrument(skip_all)]
async fn add_task_to_process_tracker<'a>(
&'a self,
_state: &'a SessionState,
_payment_attempt: &storage::PaymentAttempt,
_requeue: bool,
_schedule_time: Option<time::PrimitiveDateTime>,
) -> CustomResult<(), errors::ApiErrorResponse> {
Ok(())
}
async fn get_connector<'a>(
&'a self,
_platform: &domain::Platform,
state: &SessionState,
request: &api::PaymentsRequest,
_payment_intent: &storage::PaymentIntent,
) -> CustomResult<api::ConnectorChoice, errors::ApiErrorResponse> {
// Use a new connector in the confirm call or use the same one which was passed when
// creating the payment or if none is passed then use the routing algorithm
helpers::get_connector_default(state, request.routing.clone()).await
}
#[instrument(skip_all)]
async fn guard_payment_against_blocklist<'a>(
&'a self,
_state: &SessionState,
_platform: &domain::Platform,
_payment_data: &mut PaymentData<F>,
) -> CustomResult<bool, errors::ApiErrorResponse> {
Ok(false)
}
}
#[async_trait]
impl<F: Clone + Sync> UpdateTracker<F, PaymentData<F>, api::PaymentsRequest> for CompleteAuthorize {
#[instrument(skip_all)]
async fn update_trackers<'b>(
&'b self,
state: &'b SessionState,
req_state: ReqState,
processor: &domain::Processor,
mut payment_data: PaymentData<F>,
_customer: Option<domain::Customer>,
_frm_suggestion: Option<FrmSuggestion>,
_header_payload: hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<(CompleteAuthorizeOperation<'b, F>, PaymentData<F>)>
where
F: 'b + Send,
{
let storage_scheme = processor.get_account().storage_scheme;
let key_store = processor.get_key_store();
let payment_intent_update = hyperswitch_domain_models::payments::payment_intent::PaymentIntentUpdate::CompleteAuthorizeUpdate {
shipping_address_id: payment_data.payment_intent.shipping_address_id.clone()
};
let db = &*state.store;
let payment_intent = payment_data.payment_intent.clone();
let updated_payment_intent = db
.update_payment_intent(
payment_intent,
payment_intent_update,
key_store,
storage_scheme,
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
req_state
.event_context
.event(AuditEvent::new(AuditEventType::PaymentCompleteAuthorize))
.with(payment_data.to_event())
.emit();
payment_data.payment_intent = updated_payment_intent;
Ok((Box::new(self), payment_data))
}
}
impl<F: Send + Clone + Sync> ValidateRequest<F, api::PaymentsRequest, PaymentData<F>>
for CompleteAuthorize
{
#[instrument(skip_all)]
fn validate_request<'a, 'b>(
&'b self,
request: &api::PaymentsRequest,
processor: &'a domain::Processor,
) -> RouterResult<(
CompleteAuthorizeOperation<'b, F>,
operations::ValidateResult,
)> {
let payment_id = request
.payment_id
.clone()
.ok_or(report!(errors::ApiErrorResponse::PaymentNotFound))?;
let request_merchant_id = request.merchant_id.as_ref();
helpers::validate_merchant_id(processor.get_account().get_id(), request_merchant_id)
.change_context(errors::ApiErrorResponse::InvalidDataFormat {
field_name: "merchant_id".to_string(),
expected_format: "merchant_id from merchant account".to_string(),
})?;
helpers::validate_payment_method_fields_present(request)?;
let _mandate_type =
helpers::validate_mandate(request, payments::is_operation_confirm(self))?;
helpers::validate_recurring_details_and_token(
&request.recurring_details,
&request.payment_token,
&request.mandate_id,
)?;
Ok((
Box::new(self),
operations::ValidateResult {
merchant_id: processor.get_account().get_id().to_owned(),
payment_id,
storage_scheme: processor.get_account().storage_scheme,
requeue: matches!(
request.retry_action,
Some(api_models::enums::RetryAction::Requeue)
),
},
))
}
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/payments/operations/payment_attempt_record.rs | crates/router/src/core/payments/operations/payment_attempt_record.rs | use std::marker::PhantomData;
use api_models::{enums::FrmSuggestion, payments::PaymentsAttemptRecordRequest};
use async_trait::async_trait;
use common_utils::{
errors::CustomResult,
ext_traits::{AsyncExt, Encode, ValueExt},
types::{keymanager::ToEncryptable, MinorUnit},
};
use error_stack::ResultExt;
use hyperswitch_domain_models::payments::PaymentAttemptRecordData;
use masking::PeekInterface;
use router_env::{instrument, tracing};
use super::{BoxedOperation, Domain, GetTracker, Operation, UpdateTracker, ValidateRequest};
use crate::{
core::{
errors::{self, StorageErrorExt},
payments::{
self,
cards::create_encrypted_data,
helpers,
operations::{self, ValidateStatusForOperation},
},
},
db::{domain::types, errors::RouterResult},
routes::{app::ReqState, SessionState},
services,
types::{
api,
domain::{self, types as domain_types},
storage::{self, enums},
},
utils::{self, OptionExt},
};
#[derive(Debug, Clone, Copy)]
pub struct PaymentAttemptRecord;
type PaymentsAttemptRecordOperation<'b, F> =
BoxedOperation<'b, F, PaymentsAttemptRecordRequest, PaymentAttemptRecordData<F>>;
impl<F: Send + Clone + Sync> Operation<F, PaymentsAttemptRecordRequest> for &PaymentAttemptRecord {
type Data = PaymentAttemptRecordData<F>;
fn to_validate_request(
&self,
) -> RouterResult<
&(dyn ValidateRequest<F, PaymentsAttemptRecordRequest, Self::Data> + Send + Sync),
> {
Ok(*self)
}
fn to_get_tracker(
&self,
) -> RouterResult<&(dyn GetTracker<F, Self::Data, PaymentsAttemptRecordRequest> + Send + Sync)>
{
Ok(*self)
}
fn to_domain(
&self,
) -> RouterResult<&(dyn Domain<F, PaymentsAttemptRecordRequest, Self::Data>)> {
Ok(*self)
}
fn to_update_tracker(
&self,
) -> RouterResult<&(dyn UpdateTracker<F, Self::Data, PaymentsAttemptRecordRequest> + Send + Sync)>
{
Ok(*self)
}
}
impl ValidateStatusForOperation for PaymentAttemptRecord {
fn validate_status_for_operation(
&self,
intent_status: common_enums::IntentStatus,
) -> Result<(), errors::ApiErrorResponse> {
// need to verify this?
match intent_status {
// Payment attempt can be recorded for failed payment as well in revenue recovery flow.
common_enums::IntentStatus::RequiresPaymentMethod
| common_enums::IntentStatus::Failed
| common_enums::IntentStatus::PartiallyCaptured => Ok(()),
common_enums::IntentStatus::Succeeded
| common_enums::IntentStatus::Cancelled
| common_enums::IntentStatus::CancelledPostCapture
| common_enums::IntentStatus::Processing
| common_enums::IntentStatus::PartiallyCapturedAndProcessing
| common_enums::IntentStatus::Conflicted
| common_enums::IntentStatus::RequiresCustomerAction
| common_enums::IntentStatus::RequiresMerchantAction
| common_enums::IntentStatus::RequiresCapture
| common_enums::IntentStatus::PartiallyAuthorizedAndRequiresCapture
| common_enums::IntentStatus::PartiallyCaptured
| common_enums::IntentStatus::RequiresConfirmation
| common_enums::IntentStatus::PartiallyCapturedAndCapturable
| common_enums::IntentStatus::Expired => {
Err(errors::ApiErrorResponse::PaymentUnexpectedState {
current_flow: format!("{self:?}"),
field_name: "status".to_string(),
current_value: intent_status.to_string(),
states: [
common_enums::IntentStatus::RequiresPaymentMethod,
common_enums::IntentStatus::Failed,
]
.map(|enum_value| enum_value.to_string())
.join(", "),
})
}
}
}
}
#[async_trait]
impl<F: Send + Clone + Sync>
GetTracker<F, PaymentAttemptRecordData<F>, PaymentsAttemptRecordRequest>
for PaymentAttemptRecord
{
#[instrument(skip_all)]
async fn get_trackers<'a>(
&'a self,
state: &'a SessionState,
payment_id: &common_utils::id_type::GlobalPaymentId,
request: &PaymentsAttemptRecordRequest,
platform: &domain::Platform,
_profile: &domain::Profile,
_header_payload: &hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<operations::GetTrackerResponse<PaymentAttemptRecordData<F>>> {
let db = &*state.store;
let key_manager_state = &state.into();
let storage_scheme = platform.get_processor().get_account().storage_scheme;
let payment_intent = db
.find_payment_intent_by_id(
payment_id,
platform.get_processor().get_key_store(),
storage_scheme,
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
self.validate_status_for_operation(payment_intent.status)?;
let payment_method_billing_address = request
.payment_method_data
.as_ref()
.and_then(|data| {
data.billing
.as_ref()
.map(|address| address.clone().encode_to_value())
})
.transpose()
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed to encode payment_method_billing address")?
.map(masking::Secret::new);
let batch_encrypted_data = domain_types::crypto_operation(
key_manager_state,
common_utils::type_name!(hyperswitch_domain_models::payments::payment_attempt::PaymentAttempt),
domain_types::CryptoOperation::BatchEncrypt(
hyperswitch_domain_models::payments::payment_attempt::FromRequestEncryptablePaymentAttempt::to_encryptable(
hyperswitch_domain_models::payments::payment_attempt::FromRequestEncryptablePaymentAttempt {
payment_method_billing_address,
},
),
),
common_utils::types::keymanager::Identifier::Merchant(platform.get_processor().get_account().get_id().to_owned()),
platform.get_processor().get_key_store().key.peek(),
)
.await
.and_then(|val| val.try_into_batchoperation())
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed while encrypting payment intent details".to_string())?;
let encrypted_data =
hyperswitch_domain_models::payments::payment_attempt::FromRequestEncryptablePaymentAttempt::from_encryptable(batch_encrypted_data)
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed while encrypting payment intent details")?;
let cell_id = state.conf.cell_information.id.clone();
let payment_attempt_domain_model =
hyperswitch_domain_models::payments::payment_attempt::PaymentAttempt::create_domain_model_using_record_request(
&payment_intent,
cell_id,
storage_scheme,
request,
encrypted_data,
)
.await?;
let payment_attempt = db
.insert_payment_attempt(
platform.get_processor().get_key_store(),
payment_attempt_domain_model,
storage_scheme,
)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Could not insert payment attempt")?;
let revenue_recovery_data = hyperswitch_domain_models::payments::RevenueRecoveryData {
billing_connector_id: request.billing_connector_id.clone(),
processor_payment_method_token: request.processor_payment_method_token.clone(),
connector_customer_id: request.connector_customer_id.clone(),
retry_count: request.retry_count,
invoice_next_billing_time: request.invoice_next_billing_time,
triggered_by: request.triggered_by,
card_network: request.card_network.clone(),
card_issuer: request.card_issuer.clone(),
};
let payment_address = hyperswitch_domain_models::payment_address::PaymentAddress::new(
payment_intent
.shipping_address
.clone()
.map(|address| address.into_inner()),
payment_intent
.billing_address
.clone()
.map(|address| address.into_inner()),
payment_attempt
.payment_method_billing_address
.clone()
.map(|address| address.into_inner()),
Some(true),
);
let payment_data = PaymentAttemptRecordData {
flow: PhantomData,
payment_intent,
payment_attempt,
payment_address,
revenue_recovery_data,
};
let get_trackers_response = operations::GetTrackerResponse { payment_data };
Ok(get_trackers_response)
}
}
#[async_trait]
impl<F: Clone + Sync> UpdateTracker<F, PaymentAttemptRecordData<F>, PaymentsAttemptRecordRequest>
for PaymentAttemptRecord
{
#[instrument(skip_all)]
async fn update_trackers<'b>(
&'b self,
state: &'b SessionState,
_req_state: ReqState,
processor: &domain::Processor,
mut payment_data: PaymentAttemptRecordData<F>,
_customer: Option<domain::Customer>,
_frm_suggestion: Option<FrmSuggestion>,
_header_payload: hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<(
PaymentsAttemptRecordOperation<'b, F>,
PaymentAttemptRecordData<F>,
)>
where
F: 'b + Send,
{
let storage_scheme = processor.get_account().storage_scheme;
let key_store = processor.get_key_store();
let feature_metadata = payment_data.get_updated_feature_metadata()?;
let active_attempt_id = match payment_data.revenue_recovery_data.triggered_by {
common_enums::TriggeredBy::Internal => Some(payment_data.payment_attempt.id.clone()),
common_enums::TriggeredBy::External => None,
};
let active_attempts_group_id = payment_data.payment_intent.active_attempts_group_id.clone();
let amount_captured = payment_data.payment_intent.amount_captured;
let status = if amount_captured > Some(MinorUnit::new(0))
&& *payment_data.payment_intent.enable_partial_authorization
{
common_enums::IntentStatus::PartiallyCapturedAndProcessing
} else {
common_enums::IntentStatus::from(payment_data.payment_attempt.status)
};
let payment_intent_update =
hyperswitch_domain_models::payments::payment_intent::PaymentIntentUpdate::RecordUpdate
{
status,
feature_metadata: Box::new(feature_metadata),
updated_by: storage_scheme.to_string(),
active_attempt_id,
active_attempts_group_id,
}
;
payment_data.payment_intent = state
.store
.update_payment_intent(
payment_data.payment_intent,
payment_intent_update,
key_store,
storage_scheme,
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
Ok((Box::new(self), payment_data))
}
}
impl<F: Send + Clone> ValidateRequest<F, PaymentsAttemptRecordRequest, PaymentAttemptRecordData<F>>
for PaymentAttemptRecord
{
#[instrument(skip_all)]
fn validate_request<'a, 'b>(
&'b self,
_request: &PaymentsAttemptRecordRequest,
platform: &'a domain::Platform,
) -> RouterResult<operations::ValidateResult> {
Ok(operations::ValidateResult {
merchant_id: platform.get_processor().get_account().get_id().to_owned(),
storage_scheme: platform.get_processor().get_account().storage_scheme,
requeue: false,
})
}
}
#[async_trait]
impl<F: Clone + Send + Sync> Domain<F, PaymentsAttemptRecordRequest, PaymentAttemptRecordData<F>>
for PaymentAttemptRecord
{
#[instrument(skip_all)]
async fn get_customer_details<'a>(
&'a self,
_state: &SessionState,
_payment_data: &mut PaymentAttemptRecordData<F>,
_merchant_key_store: &domain::MerchantKeyStore,
_storage_scheme: enums::MerchantStorageScheme,
) -> CustomResult<
(
BoxedOperation<'a, F, PaymentsAttemptRecordRequest, PaymentAttemptRecordData<F>>,
Option<domain::Customer>,
),
errors::StorageError,
> {
Ok((Box::new(self), None))
}
#[instrument(skip_all)]
async fn make_pm_data<'a>(
&'a self,
_state: &'a SessionState,
_payment_data: &mut PaymentAttemptRecordData<F>,
_storage_scheme: enums::MerchantStorageScheme,
_merchant_key_store: &domain::MerchantKeyStore,
_customer: &Option<domain::Customer>,
_business_profile: &domain::Profile,
_should_retry_with_pan: bool,
) -> RouterResult<(
PaymentsAttemptRecordOperation<'a, F>,
Option<domain::PaymentMethodData>,
Option<String>,
)> {
Ok((Box::new(self), None, None))
}
#[instrument(skip_all)]
async fn perform_routing<'a>(
&'a self,
_platform: &domain::Platform,
_business_profile: &domain::Profile,
_state: &SessionState,
_payment_data: &mut PaymentAttemptRecordData<F>,
) -> CustomResult<api::ConnectorCallType, errors::ApiErrorResponse> {
Ok(api::ConnectorCallType::Skip)
}
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/payments/operations/payment_confirm_intent.rs | crates/router/src/core/payments/operations/payment_confirm_intent.rs | use api_models::{enums::FrmSuggestion, payments::PaymentsConfirmIntentRequest};
use async_trait::async_trait;
use common_utils::{ext_traits::Encode, fp_utils::when, id_type, types::keymanager::ToEncryptable};
use error_stack::ResultExt;
use hyperswitch_domain_models::payments::PaymentConfirmData;
use hyperswitch_interfaces::api::ConnectorSpecifications;
use masking::{ExposeOptionInterface, PeekInterface};
use router_env::{instrument, tracing};
use super::{Domain, GetTracker, Operation, UpdateTracker, ValidateRequest};
use crate::{
core::{
admin,
errors::{self, CustomResult, RouterResult, StorageErrorExt},
payment_methods,
payments::{
self, call_decision_manager, helpers,
operations::{self, ValidateStatusForOperation},
populate_surcharge_details, CustomerDetails, OperationSessionSetters, PaymentAddress,
PaymentData,
},
utils as core_utils,
},
routes::{app::ReqState, SessionState},
services::{self, connector_integration_interface::ConnectorEnum},
types::{
self,
api::{self, ConnectorCallType, PaymentIdTypeExt},
domain::{self, types as domain_types},
storage::{self, enums as storage_enums},
},
utils::{self, OptionExt},
};
#[derive(Debug, Clone, Copy)]
pub struct PaymentIntentConfirm;
impl ValidateStatusForOperation for PaymentIntentConfirm {
/// Validate if the current operation can be performed on the current status of the payment intent
fn validate_status_for_operation(
&self,
intent_status: common_enums::IntentStatus,
) -> Result<(), errors::ApiErrorResponse> {
match intent_status {
common_enums::IntentStatus::RequiresPaymentMethod => Ok(()),
common_enums::IntentStatus::Succeeded
| common_enums::IntentStatus::Conflicted
| common_enums::IntentStatus::Failed
| common_enums::IntentStatus::Cancelled
| common_enums::IntentStatus::CancelledPostCapture
| common_enums::IntentStatus::Processing
| common_enums::IntentStatus::PartiallyCapturedAndProcessing
| common_enums::IntentStatus::RequiresCustomerAction
| common_enums::IntentStatus::RequiresMerchantAction
| common_enums::IntentStatus::RequiresCapture
| common_enums::IntentStatus::PartiallyAuthorizedAndRequiresCapture
| common_enums::IntentStatus::PartiallyCaptured
| common_enums::IntentStatus::RequiresConfirmation
| common_enums::IntentStatus::PartiallyCapturedAndCapturable
| common_enums::IntentStatus::Expired => {
Err(errors::ApiErrorResponse::PaymentUnexpectedState {
current_flow: format!("{self:?}"),
field_name: "status".to_string(),
current_value: intent_status.to_string(),
states: ["requires_payment_method".to_string()].join(", "),
})
}
}
}
}
type BoxedConfirmOperation<'b, F> =
super::BoxedOperation<'b, F, PaymentsConfirmIntentRequest, PaymentConfirmData<F>>;
// TODO: change the macro to include changes for v2
// TODO: PaymentData in the macro should be an input
impl<F: Send + Clone + Sync> Operation<F, PaymentsConfirmIntentRequest> for &PaymentIntentConfirm {
type Data = PaymentConfirmData<F>;
fn to_validate_request(
&self,
) -> RouterResult<
&(dyn ValidateRequest<F, PaymentsConfirmIntentRequest, Self::Data> + Send + Sync),
> {
Ok(*self)
}
fn to_get_tracker(
&self,
) -> RouterResult<&(dyn GetTracker<F, Self::Data, PaymentsConfirmIntentRequest> + Send + Sync)>
{
Ok(*self)
}
fn to_domain(
&self,
) -> RouterResult<&(dyn Domain<F, PaymentsConfirmIntentRequest, Self::Data>)> {
Ok(*self)
}
fn to_update_tracker(
&self,
) -> RouterResult<&(dyn UpdateTracker<F, Self::Data, PaymentsConfirmIntentRequest> + Send + Sync)>
{
Ok(*self)
}
}
#[automatically_derived]
impl<F: Send + Clone + Sync> Operation<F, PaymentsConfirmIntentRequest> for PaymentIntentConfirm {
type Data = PaymentConfirmData<F>;
fn to_validate_request(
&self,
) -> RouterResult<
&(dyn ValidateRequest<F, PaymentsConfirmIntentRequest, Self::Data> + Send + Sync),
> {
Ok(self)
}
fn to_get_tracker(
&self,
) -> RouterResult<&(dyn GetTracker<F, Self::Data, PaymentsConfirmIntentRequest> + Send + Sync)>
{
Ok(self)
}
fn to_domain(&self) -> RouterResult<&dyn Domain<F, PaymentsConfirmIntentRequest, Self::Data>> {
Ok(self)
}
fn to_update_tracker(
&self,
) -> RouterResult<&(dyn UpdateTracker<F, Self::Data, PaymentsConfirmIntentRequest> + Send + Sync)>
{
Ok(self)
}
}
impl<F: Send + Clone + Sync> ValidateRequest<F, PaymentsConfirmIntentRequest, PaymentConfirmData<F>>
for PaymentIntentConfirm
{
#[instrument(skip_all)]
fn validate_request<'a, 'b>(
&'b self,
request: &PaymentsConfirmIntentRequest,
platform: &'a domain::Platform,
) -> RouterResult<operations::ValidateResult> {
let validate_result = operations::ValidateResult {
merchant_id: platform.get_processor().get_account().get_id().to_owned(),
storage_scheme: platform.get_processor().get_account().storage_scheme,
requeue: false,
};
Ok(validate_result)
}
}
#[async_trait]
impl<F: Send + Clone + Sync> GetTracker<F, PaymentConfirmData<F>, PaymentsConfirmIntentRequest>
for PaymentIntentConfirm
{
#[instrument(skip_all)]
async fn get_trackers<'a>(
&'a self,
state: &'a SessionState,
payment_id: &id_type::GlobalPaymentId,
request: &PaymentsConfirmIntentRequest,
platform: &domain::Platform,
profile: &domain::Profile,
header_payload: &hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<operations::GetTrackerResponse<PaymentConfirmData<F>>> {
let db = &*state.store;
let key_manager_state = &state.into();
let storage_scheme = platform.get_processor().get_account().storage_scheme;
let payment_intent = db
.find_payment_intent_by_id(
payment_id,
platform.get_processor().get_key_store(),
storage_scheme,
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
// TODO (#7195): Add platform merchant account validation once publishable key auth is solved
self.validate_status_for_operation(payment_intent.status)?;
let cell_id = state.conf.cell_information.id.clone();
let batch_encrypted_data = domain_types::crypto_operation(
key_manager_state,
common_utils::type_name!(hyperswitch_domain_models::payments::payment_attempt::PaymentAttempt),
domain_types::CryptoOperation::BatchEncrypt(
hyperswitch_domain_models::payments::payment_attempt::FromRequestEncryptablePaymentAttempt::to_encryptable(
hyperswitch_domain_models::payments::payment_attempt::FromRequestEncryptablePaymentAttempt {
payment_method_billing_address: request.payment_method_data.billing.as_ref().map(|address| address.clone().encode_to_value()).transpose().change_context(errors::ApiErrorResponse::InternalServerError).attach_printable("Failed to encode payment_method_billing address")?.map(masking::Secret::new),
},
),
),
common_utils::types::keymanager::Identifier::Merchant(platform.get_processor().get_account().get_id().to_owned()),
platform.get_processor().get_key_store().key.peek(),
)
.await
.and_then(|val| val.try_into_batchoperation())
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed while encrypting payment intent details".to_string())?;
let encrypted_data =
hyperswitch_domain_models::payments::payment_attempt::FromRequestEncryptablePaymentAttempt::from_encryptable(batch_encrypted_data)
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed while encrypting payment intent details")?;
let payment_attempt_domain_model =
hyperswitch_domain_models::payments::payment_attempt::PaymentAttempt::create_domain_model(
&payment_intent,
cell_id,
storage_scheme,
request,
encrypted_data
)
.await?;
let payment_attempt: hyperswitch_domain_models::payments::payment_attempt::PaymentAttempt =
db.insert_payment_attempt(
platform.get_processor().get_key_store(),
payment_attempt_domain_model,
storage_scheme,
)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Could not insert payment attempt")?;
let payment_method_data = request
.payment_method_data
.payment_method_data
.clone()
.map(hyperswitch_domain_models::payment_method_data::PaymentMethodData::from);
if request.payment_token.is_some() {
when(
!matches!(
payment_method_data,
Some(domain::payment_method_data::PaymentMethodData::CardToken(_))
),
|| {
Err(errors::ApiErrorResponse::InvalidDataValue {
field_name: "payment_method_data",
})
.attach_printable(
"payment_method_data should be card_token when a token is passed",
)
},
)?;
};
let payment_address = hyperswitch_domain_models::payment_address::PaymentAddress::new(
payment_intent
.shipping_address
.clone()
.map(|address| address.into_inner()),
payment_intent
.billing_address
.clone()
.map(|address| address.into_inner()),
payment_attempt
.payment_method_billing_address
.clone()
.map(|address| address.into_inner()),
Some(true),
);
let merchant_connector_details = request.merchant_connector_details.clone();
let payment_data = PaymentConfirmData {
flow: std::marker::PhantomData,
payment_intent,
payment_attempt,
payment_method_data,
payment_address,
mandate_data: None,
payment_method: None,
merchant_connector_details,
external_vault_pmd: None,
webhook_url: request
.webhook_url
.as_ref()
.map(|url| url.get_string_repr().to_string()),
};
let get_trackers_response = operations::GetTrackerResponse { payment_data };
Ok(get_trackers_response)
}
#[instrument(skip_all)]
async fn get_trackers_for_split_payments<'a>(
&'a self,
state: &'a SessionState,
payment_id: &id_type::GlobalPaymentId,
request: &PaymentsConfirmIntentRequest,
platform: &domain::Platform,
_profile: &domain::Profile,
_header_payload: &hyperswitch_domain_models::payments::HeaderPayload,
pm_split_amount_data: domain::PaymentMethodDetailsWithSplitAmount,
attempts_group_id: &id_type::GlobalAttemptGroupId,
) -> RouterResult<operations::GetTrackerResponse<PaymentConfirmData<F>>> {
let db = &*state.store;
let key_manager_state = &state.into();
let storage_scheme = platform.get_processor().get_account().storage_scheme;
let payment_intent = db
.find_payment_intent_by_id(
payment_id,
platform.get_processor().get_key_store(),
storage_scheme,
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
// TODO (#7195): Add platform merchant account validation once publishable key auth is solved
self.validate_status_for_operation(payment_intent.status)?;
let cell_id = state.conf.cell_information.id.clone();
let batch_encrypted_data = domain_types::crypto_operation(
key_manager_state,
common_utils::type_name!(hyperswitch_domain_models::payments::payment_attempt::PaymentAttempt),
domain_types::CryptoOperation::BatchEncrypt(
hyperswitch_domain_models::payments::payment_attempt::FromRequestEncryptablePaymentAttempt::to_encryptable(
hyperswitch_domain_models::payments::payment_attempt::FromRequestEncryptablePaymentAttempt {
payment_method_billing_address: request.payment_method_data.billing.as_ref().map(|address| address.clone().encode_to_value()).transpose().change_context(errors::ApiErrorResponse::InternalServerError).attach_printable("Failed to encode payment_method_billing address")?.map(masking::Secret::new),
},
),
),
common_utils::types::keymanager::Identifier::Merchant(platform.get_processor().get_account().get_id().to_owned()),
platform.get_processor().get_key_store().key.peek(),
)
.await
.and_then(|val| val.try_into_batchoperation())
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed while encrypting payment intent details".to_string())?;
let encrypted_data =
hyperswitch_domain_models::payments::payment_attempt::FromRequestEncryptablePaymentAttempt::from_encryptable(batch_encrypted_data)
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed while encrypting payment intent details")?;
let payment_attempt_domain_model =
crate::core::split_payments::create_domain_model_for_split_payment(
&payment_intent,
cell_id,
storage_scheme,
request,
encrypted_data,
pm_split_amount_data.split_amount,
attempts_group_id,
pm_split_amount_data
.payment_method_details
.payment_method_type,
pm_split_amount_data
.payment_method_details
.payment_method_subtype,
)
.await?;
let payment_attempt: hyperswitch_domain_models::payments::payment_attempt::PaymentAttempt =
db.insert_payment_attempt(
platform.get_processor().get_key_store(),
payment_attempt_domain_model,
storage_scheme,
)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Could not insert payment attempt")?;
let payment_method_data =
hyperswitch_domain_models::payment_method_data::PaymentMethodData::from(
pm_split_amount_data
.payment_method_details
.payment_method_data,
);
let payment_address = hyperswitch_domain_models::payment_address::PaymentAddress::new(
payment_intent
.shipping_address
.clone()
.map(|address| address.into_inner()),
payment_intent
.billing_address
.clone()
.map(|address| address.into_inner()),
payment_attempt
.payment_method_billing_address
.clone()
.map(|address| address.into_inner()),
Some(true),
);
let merchant_connector_details = request.merchant_connector_details.clone();
let payment_data = PaymentConfirmData {
flow: std::marker::PhantomData,
payment_intent,
payment_attempt,
payment_method_data: Some(payment_method_data),
payment_address,
mandate_data: None,
payment_method: None,
merchant_connector_details,
external_vault_pmd: None,
webhook_url: request
.webhook_url
.as_ref()
.map(|url| url.get_string_repr().to_string()),
};
let get_trackers_response = operations::GetTrackerResponse { payment_data };
Ok(get_trackers_response)
}
}
#[async_trait]
impl<F: Clone + Send + Sync> Domain<F, PaymentsConfirmIntentRequest, PaymentConfirmData<F>>
for PaymentIntentConfirm
{
async fn get_customer_details<'a>(
&'a self,
state: &SessionState,
payment_data: &mut PaymentConfirmData<F>,
merchant_key_store: &domain::MerchantKeyStore,
storage_scheme: storage_enums::MerchantStorageScheme,
) -> CustomResult<(BoxedConfirmOperation<'a, F>, Option<domain::Customer>), errors::StorageError>
{
match payment_data.payment_intent.customer_id.clone() {
Some(id) => {
let customer = state
.store
.find_customer_by_global_id(&id, merchant_key_store, storage_scheme)
.await?;
Ok((Box::new(self), Some(customer)))
}
None => Ok((Box::new(self), None)),
}
}
#[instrument(skip_all)]
async fn update_customer<'a>(
&'a self,
state: &'a SessionState,
provider: &domain::Provider,
customer: Option<domain::Customer>,
updated_customer: Option<storage::CustomerUpdate>,
) -> RouterResult<()> {
if let Some((customer, updated_customer)) = customer.zip(updated_customer) {
let customer_id = customer.get_id().clone();
let _updated_customer = state
.store
.update_customer_by_global_id(
&customer_id,
customer,
updated_customer,
provider.get_key_store(),
provider.get_account().storage_scheme,
)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed to update customer during `update_customer`")?;
}
Ok(())
}
async fn run_decision_manager<'a>(
&'a self,
state: &SessionState,
payment_data: &mut PaymentConfirmData<F>,
business_profile: &domain::Profile,
) -> CustomResult<(), errors::ApiErrorResponse> {
let authentication_type = payment_data.payment_intent.authentication_type;
let authentication_type = match business_profile.three_ds_decision_manager_config.as_ref() {
Some(three_ds_decision_manager_config) => call_decision_manager(
state,
three_ds_decision_manager_config.clone(),
payment_data,
)?,
None => authentication_type,
};
if let Some(auth_type) = authentication_type {
payment_data.payment_attempt.authentication_type = auth_type;
}
Ok(())
}
#[instrument(skip_all)]
async fn make_pm_data<'a>(
&'a self,
state: &'a SessionState,
payment_data: &mut PaymentConfirmData<F>,
storage_scheme: storage_enums::MerchantStorageScheme,
key_store: &domain::MerchantKeyStore,
customer: &Option<domain::Customer>,
business_profile: &domain::Profile,
_should_retry_with_pan: bool,
) -> RouterResult<(
BoxedConfirmOperation<'a, F>,
Option<domain::PaymentMethodData>,
Option<String>,
)> {
Ok((Box::new(self), None, None))
}
#[cfg(feature = "v2")]
async fn perform_routing<'a>(
&'a self,
platform: &domain::Platform,
business_profile: &domain::Profile,
state: &SessionState,
payment_data: &mut PaymentConfirmData<F>,
) -> CustomResult<ConnectorCallType, errors::ApiErrorResponse> {
payments::connector_selection(state, platform, business_profile, payment_data, None).await
}
#[instrument(skip_all)]
async fn populate_payment_data<'a>(
&'a self,
state: &SessionState,
payment_data: &mut PaymentConfirmData<F>,
_platform: &domain::Platform,
business_profile: &domain::Profile,
connector_data: &api::ConnectorData,
) -> CustomResult<(), errors::ApiErrorResponse> {
let connector_request_reference_id = connector_data
.connector
.generate_connector_request_reference_id(
&payment_data.payment_intent,
&payment_data.payment_attempt,
);
payment_data.set_connector_request_reference_id(Some(connector_request_reference_id));
Ok(())
}
#[cfg(feature = "v2")]
async fn create_or_fetch_payment_method<'a>(
&'a self,
state: &SessionState,
platform: &domain::Platform,
business_profile: &domain::Profile,
payment_data: &mut PaymentConfirmData<F>,
) -> CustomResult<(), errors::ApiErrorResponse> {
let (payment_method, payment_method_data) = match (
&payment_data.payment_attempt.payment_token,
&payment_data.payment_method_data,
&payment_data.payment_attempt.customer_acceptance,
) {
(
Some(payment_token),
Some(domain::payment_method_data::PaymentMethodData::CardToken(card_token)),
None,
) => {
let (card_cvc, card_holder_name) = {
(
card_token
.card_cvc
.clone()
.ok_or(errors::ApiErrorResponse::InvalidDataValue {
field_name: "card_cvc",
})
.or(
payment_methods::vault::retrieve_and_delete_cvc_from_payment_token(
state,
payment_token,
payment_data.payment_attempt.payment_method_type,
platform.get_processor().get_key_store().key.get_inner(),
)
.await,
)
.attach_printable("card_cvc not provided")?,
card_token.card_holder_name.clone(),
)
};
let (payment_method, vault_data) =
payment_methods::vault::retrieve_payment_method_from_vault_using_payment_token(
state,
platform,
business_profile,
payment_token,
&payment_data.payment_attempt.payment_method_type,
)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed to retrieve payment method from vault")?;
match vault_data {
domain::vault::PaymentMethodVaultingData::Card(card_detail) => {
let pm_data_from_vault =
domain::payment_method_data::PaymentMethodData::Card(
domain::payment_method_data::Card::from((
card_detail,
card_cvc,
card_holder_name,
)),
);
(Some(payment_method), Some(pm_data_from_vault))
}
_ => Err(errors::ApiErrorResponse::NotImplemented {
message: errors::NotImplementedMessage::Reason(
"Non-card Tokenization not implemented".to_string(),
),
})?,
}
}
(Some(_payment_token), _, _) => Err(errors::ApiErrorResponse::InvalidDataValue {
field_name: "payment_method_data",
})
.attach_printable("payment_method_data should be card_token when a token is passed")?,
(None, Some(domain::PaymentMethodData::Card(card)), Some(_customer_acceptance)) => {
let customer_id = match &payment_data.payment_intent.customer_id {
Some(customer_id) => customer_id.clone(),
None => {
return Err(errors::ApiErrorResponse::InvalidDataValue {
field_name: "customer_id",
})
.attach_printable("customer_id not provided");
}
};
let pm_create_data =
api::PaymentMethodCreateData::Card(api::CardDetail::from(card.clone()));
let req = api::PaymentMethodCreate {
payment_method_type: payment_data.payment_attempt.payment_method_type,
payment_method_subtype: payment_data.payment_attempt.payment_method_subtype,
metadata: None,
customer_id: Some(customer_id),
payment_method_data: pm_create_data,
billing: None,
psp_tokenization: None,
network_tokenization: None,
storage_type: Some(common_enums::StorageType::Persistent), //since customer acceptance is present, we always store it persistently
};
let (_pm_response, payment_method) =
Box::pin(payment_methods::create_payment_method_core(
state,
&state.get_req_state(),
req,
platform,
business_profile,
))
.await?;
// Don't modify payment_method_data in this case, only the payment_method and payment_method_id
(Some(payment_method), None)
}
_ => (None, None), // Pass payment_data unmodified for any other case
};
if let Some(pm_data) = payment_method_data {
payment_data.update_payment_method_data(pm_data);
}
if let Some(pm) = payment_method {
payment_data.update_payment_method_and_pm_id(pm.get_id().clone(), pm);
}
Ok(())
}
#[cfg(feature = "v2")]
async fn get_connector_from_request<'a>(
&'a self,
state: &SessionState,
request: &PaymentsConfirmIntentRequest,
payment_data: &mut PaymentConfirmData<F>,
) -> CustomResult<api::ConnectorData, errors::ApiErrorResponse> {
let connector_data = helpers::get_connector_data_from_request(
state,
request.merchant_connector_details.clone(),
)
.await?;
payment_data
.set_connector_in_payment_attempt(Some(connector_data.connector_name.to_string()));
Ok(connector_data)
}
async fn get_connector_tokenization_action<'a>(
&'a self,
state: &SessionState,
payment_data: &PaymentConfirmData<F>,
) -> RouterResult<payments::TokenizationAction> {
let connector = payment_data.payment_attempt.connector.to_owned();
let is_connector_mandate_flow = payment_data
.mandate_data
.as_ref()
.and_then(|mandate_details| mandate_details.mandate_reference_id.as_ref())
.map(|mandate_reference| match mandate_reference {
api_models::payments::MandateReferenceId::ConnectorMandateId(_) => true,
api_models::payments::MandateReferenceId::NetworkMandateId(_)
| api_models::payments::MandateReferenceId::NetworkTokenWithNTI(_) => false,
})
.unwrap_or(false);
let tokenization_action = match connector {
Some(_) if is_connector_mandate_flow => {
payments::TokenizationAction::SkipConnectorTokenization
}
Some(connector) => {
let payment_method = payment_data
.payment_attempt
.get_payment_method()
.ok_or_else(|| errors::ApiErrorResponse::InternalServerError)
.attach_printable("Payment method not found")?;
let payment_method_type: Option<common_enums::PaymentMethodType> =
payment_data.payment_attempt.get_payment_method_type();
let mandate_flow_enabled = payment_data.payment_intent.setup_future_usage;
let is_connector_tokenization_enabled =
payments::is_payment_method_tokenization_enabled_for_connector(
state,
&connector,
payment_method,
payment_method_type,
mandate_flow_enabled,
)?;
if is_connector_tokenization_enabled {
payments::TokenizationAction::TokenizeInConnector
} else {
payments::TokenizationAction::SkipConnectorTokenization
}
}
None => payments::TokenizationAction::SkipConnectorTokenization,
};
Ok(tokenization_action)
}
}
#[async_trait]
impl<F: Clone + Sync> UpdateTracker<F, PaymentConfirmData<F>, PaymentsConfirmIntentRequest>
for PaymentIntentConfirm
{
#[instrument(skip_all)]
async fn update_trackers<'b>(
&'b self,
state: &'b SessionState,
_req_state: ReqState,
processor: &domain::Processor,
mut payment_data: PaymentConfirmData<F>,
_customer: Option<domain::Customer>,
_frm_suggestion: Option<FrmSuggestion>,
_header_payload: hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<(BoxedConfirmOperation<'b, F>, PaymentConfirmData<F>)>
where
F: 'b + Send,
{
let db = &*state.store;
let storage_scheme = processor.get_account().storage_scheme;
let key_store = processor.get_key_store();
let intent_status = common_enums::IntentStatus::Processing;
let attempt_status = common_enums::AttemptStatus::Pending;
let connector = payment_data
.payment_attempt
.connector
.clone()
.get_required_value("connector")
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Connector is none when constructing response")?;
// If `merchant_connector_details` are present in the payment request, `merchant_connector_id` will not be populated.
let merchant_connector_id = match &payment_data.merchant_connector_details {
Some(_details) => None,
None => Some(
payment_data
.payment_attempt
.merchant_connector_id
.clone()
.get_required_value("merchant_connector_id")
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Merchant connector id is none when constructing response")?,
),
};
let payment_intent_update =
hyperswitch_domain_models::payments::payment_intent::PaymentIntentUpdate::ConfirmIntent {
status: intent_status,
updated_by: storage_scheme.to_string(),
active_attempt_id: Some(payment_data.payment_attempt.id.clone()),
};
let authentication_type = payment_data.payment_attempt.authentication_type;
let connector_request_reference_id = payment_data
.payment_attempt
.connector_request_reference_id
.clone();
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | true |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/payments/operations/payment_get_intent.rs | crates/router/src/core/payments/operations/payment_get_intent.rs | use std::marker::PhantomData;
use api_models::{enums::FrmSuggestion, payments::PaymentsGetIntentRequest};
use async_trait::async_trait;
use common_utils::errors::CustomResult;
use router_env::{instrument, tracing};
use super::{BoxedOperation, Domain, GetTracker, Operation, UpdateTracker, ValidateRequest};
use crate::{
core::{
errors::{self, RouterResult},
payments::{self, helpers, operations},
},
db::errors::StorageErrorExt,
routes::{app::ReqState, SessionState},
types::{
api, domain,
storage::{self, enums},
},
};
#[derive(Debug, Clone, Copy)]
pub struct PaymentGetIntent;
impl<F: Send + Clone + Sync> Operation<F, PaymentsGetIntentRequest> for &PaymentGetIntent {
type Data = payments::PaymentIntentData<F>;
fn to_validate_request(
&self,
) -> RouterResult<&(dyn ValidateRequest<F, PaymentsGetIntentRequest, Self::Data> + Send + Sync)>
{
Ok(*self)
}
fn to_get_tracker(
&self,
) -> RouterResult<&(dyn GetTracker<F, Self::Data, PaymentsGetIntentRequest> + Send + Sync)>
{
Ok(*self)
}
fn to_domain(&self) -> RouterResult<&(dyn Domain<F, PaymentsGetIntentRequest, Self::Data>)> {
Ok(*self)
}
fn to_update_tracker(
&self,
) -> RouterResult<&(dyn UpdateTracker<F, Self::Data, PaymentsGetIntentRequest> + Send + Sync)>
{
Ok(*self)
}
}
impl<F: Send + Clone + Sync> Operation<F, PaymentsGetIntentRequest> for PaymentGetIntent {
type Data = payments::PaymentIntentData<F>;
fn to_validate_request(
&self,
) -> RouterResult<&(dyn ValidateRequest<F, PaymentsGetIntentRequest, Self::Data> + Send + Sync)>
{
Ok(self)
}
fn to_get_tracker(
&self,
) -> RouterResult<&(dyn GetTracker<F, Self::Data, PaymentsGetIntentRequest> + Send + Sync)>
{
Ok(self)
}
fn to_domain(&self) -> RouterResult<&dyn Domain<F, PaymentsGetIntentRequest, Self::Data>> {
Ok(self)
}
fn to_update_tracker(
&self,
) -> RouterResult<&(dyn UpdateTracker<F, Self::Data, PaymentsGetIntentRequest> + Send + Sync)>
{
Ok(self)
}
}
type PaymentsGetIntentOperation<'b, F> =
BoxedOperation<'b, F, PaymentsGetIntentRequest, payments::PaymentIntentData<F>>;
#[async_trait]
impl<F: Send + Clone + Sync> GetTracker<F, payments::PaymentIntentData<F>, PaymentsGetIntentRequest>
for PaymentGetIntent
{
#[instrument(skip_all)]
async fn get_trackers<'a>(
&'a self,
state: &'a SessionState,
_payment_id: &common_utils::id_type::GlobalPaymentId,
request: &PaymentsGetIntentRequest,
platform: &domain::Platform,
_profile: &domain::Profile,
_header_payload: &hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<operations::GetTrackerResponse<payments::PaymentIntentData<F>>> {
let db = &*state.store;
let storage_scheme = platform.get_processor().get_account().storage_scheme;
let payment_intent = db
.find_payment_intent_by_id(
&request.id,
platform.get_processor().get_key_store(),
storage_scheme,
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
let payment_data = payments::PaymentIntentData {
flow: PhantomData,
payment_intent,
// todo : add a way to fetch client secret if required
client_secret: None,
sessions_token: vec![],
vault_session_details: None,
connector_customer_id: None,
};
let get_trackers_response = operations::GetTrackerResponse { payment_data };
Ok(get_trackers_response)
}
}
#[async_trait]
impl<F: Clone + Sync> UpdateTracker<F, payments::PaymentIntentData<F>, PaymentsGetIntentRequest>
for PaymentGetIntent
{
#[instrument(skip_all)]
async fn update_trackers<'b>(
&'b self,
_state: &'b SessionState,
_req_state: ReqState,
_processor: &domain::Processor,
payment_data: payments::PaymentIntentData<F>,
_customer: Option<domain::Customer>,
_frm_suggestion: Option<FrmSuggestion>,
_header_payload: hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<(
PaymentsGetIntentOperation<'b, F>,
payments::PaymentIntentData<F>,
)>
where
F: 'b + Send,
{
Ok((Box::new(self), payment_data))
}
}
impl<F: Send + Clone + Sync>
ValidateRequest<F, PaymentsGetIntentRequest, payments::PaymentIntentData<F>>
for PaymentGetIntent
{
#[instrument(skip_all)]
fn validate_request<'a, 'b>(
&'b self,
_request: &PaymentsGetIntentRequest,
platform: &'a domain::Platform,
) -> RouterResult<operations::ValidateResult> {
Ok(operations::ValidateResult {
merchant_id: platform.get_processor().get_account().get_id().to_owned(),
storage_scheme: platform.get_processor().get_account().storage_scheme,
requeue: false,
})
}
}
#[async_trait]
impl<F: Clone + Send + Sync> Domain<F, PaymentsGetIntentRequest, payments::PaymentIntentData<F>>
for PaymentGetIntent
{
#[instrument(skip_all)]
async fn get_customer_details<'a>(
&'a self,
state: &SessionState,
payment_data: &mut payments::PaymentIntentData<F>,
merchant_key_store: &domain::MerchantKeyStore,
storage_scheme: enums::MerchantStorageScheme,
) -> CustomResult<
(
BoxedOperation<'a, F, PaymentsGetIntentRequest, payments::PaymentIntentData<F>>,
Option<domain::Customer>,
),
errors::StorageError,
> {
Ok((Box::new(self), None))
}
#[instrument(skip_all)]
async fn make_pm_data<'a>(
&'a self,
_state: &'a SessionState,
_payment_data: &mut payments::PaymentIntentData<F>,
_storage_scheme: enums::MerchantStorageScheme,
_merchant_key_store: &domain::MerchantKeyStore,
_customer: &Option<domain::Customer>,
_business_profile: &domain::Profile,
_should_retry_with_pan: bool,
) -> RouterResult<(
PaymentsGetIntentOperation<'a, F>,
Option<domain::PaymentMethodData>,
Option<String>,
)> {
Ok((Box::new(self), None, None))
}
#[instrument(skip_all)]
async fn perform_routing<'a>(
&'a self,
platform: &domain::Platform,
business_profile: &domain::Profile,
state: &SessionState,
// TODO: do not take the whole payment data here
payment_data: &mut payments::PaymentIntentData<F>,
) -> CustomResult<api::ConnectorCallType, errors::ApiErrorResponse> {
Ok(api::ConnectorCallType::Skip)
}
#[instrument(skip_all)]
async fn guard_payment_against_blocklist<'a>(
&'a self,
_state: &SessionState,
_platform: &domain::Platform,
_payment_data: &mut payments::PaymentIntentData<F>,
) -> CustomResult<bool, errors::ApiErrorResponse> {
Ok(false)
}
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/payments/operations/payment_create_intent.rs | crates/router/src/core/payments/operations/payment_create_intent.rs | use std::marker::PhantomData;
use api_models::{enums::FrmSuggestion, payments::PaymentsCreateIntentRequest};
use async_trait::async_trait;
use common_utils::{
errors::CustomResult,
ext_traits::Encode,
types::{authentication, keymanager::ToEncryptable},
};
use error_stack::ResultExt;
use masking::PeekInterface;
use router_env::{instrument, tracing};
use super::{BoxedOperation, Domain, GetTracker, Operation, UpdateTracker, ValidateRequest};
use crate::{
core::{
errors::{self, RouterResult, StorageErrorExt},
payments::{self, helpers, operations},
},
routes::{app::ReqState, SessionState},
types::{
api,
domain::{self, types as domain_types},
storage::{self, enums},
},
};
#[derive(Debug, Clone, Copy)]
pub struct PaymentIntentCreate;
impl<F: Send + Clone + Sync> Operation<F, PaymentsCreateIntentRequest> for &PaymentIntentCreate {
type Data = payments::PaymentIntentData<F>;
fn to_validate_request(
&self,
) -> RouterResult<
&(dyn ValidateRequest<F, PaymentsCreateIntentRequest, Self::Data> + Send + Sync),
> {
Ok(*self)
}
fn to_get_tracker(
&self,
) -> RouterResult<&(dyn GetTracker<F, Self::Data, PaymentsCreateIntentRequest> + Send + Sync)>
{
Ok(*self)
}
fn to_domain(&self) -> RouterResult<&(dyn Domain<F, PaymentsCreateIntentRequest, Self::Data>)> {
Ok(*self)
}
fn to_update_tracker(
&self,
) -> RouterResult<&(dyn UpdateTracker<F, Self::Data, PaymentsCreateIntentRequest> + Send + Sync)>
{
Ok(*self)
}
}
impl<F: Send + Clone + Sync> Operation<F, PaymentsCreateIntentRequest> for PaymentIntentCreate {
type Data = payments::PaymentIntentData<F>;
fn to_validate_request(
&self,
) -> RouterResult<
&(dyn ValidateRequest<F, PaymentsCreateIntentRequest, Self::Data> + Send + Sync),
> {
Ok(self)
}
fn to_get_tracker(
&self,
) -> RouterResult<&(dyn GetTracker<F, Self::Data, PaymentsCreateIntentRequest> + Send + Sync)>
{
Ok(self)
}
fn to_domain(&self) -> RouterResult<&dyn Domain<F, PaymentsCreateIntentRequest, Self::Data>> {
Ok(self)
}
fn to_update_tracker(
&self,
) -> RouterResult<&(dyn UpdateTracker<F, Self::Data, PaymentsCreateIntentRequest> + Send + Sync)>
{
Ok(self)
}
}
type PaymentsCreateIntentOperation<'b, F> =
BoxedOperation<'b, F, PaymentsCreateIntentRequest, payments::PaymentIntentData<F>>;
#[async_trait]
impl<F: Send + Clone + Sync>
GetTracker<F, payments::PaymentIntentData<F>, PaymentsCreateIntentRequest>
for PaymentIntentCreate
{
#[instrument(skip_all)]
async fn get_trackers<'a>(
&'a self,
state: &'a SessionState,
payment_id: &common_utils::id_type::GlobalPaymentId,
request: &PaymentsCreateIntentRequest,
platform: &domain::Platform,
profile: &domain::Profile,
_header_payload: &hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<operations::GetTrackerResponse<payments::PaymentIntentData<F>>> {
let db = &*state.store;
if let Some(routing_algorithm_id) = request.routing_algorithm_id.as_ref() {
helpers::validate_routing_id_with_profile_id(
db,
routing_algorithm_id,
profile.get_id(),
)
.await?;
}
let key_manager_state = &state.into();
let cell_id = state.conf.cell_information.id.clone();
let storage_scheme = platform.get_processor().get_account().storage_scheme;
let batch_encrypted_data = domain_types::crypto_operation(
key_manager_state,
common_utils::type_name!(hyperswitch_domain_models::payments::PaymentIntent),
domain_types::CryptoOperation::BatchEncrypt(
hyperswitch_domain_models::payments::FromRequestEncryptablePaymentIntent::to_encryptable(
hyperswitch_domain_models::payments::FromRequestEncryptablePaymentIntent {
shipping_address: request.shipping.clone().map(|address| address.encode_to_value()).transpose().change_context(errors::ApiErrorResponse::InternalServerError).attach_printable("Failed to encode shipping address")?.map(masking::Secret::new),
billing_address: request.billing.clone().map(|address| address.encode_to_value()).transpose().change_context(errors::ApiErrorResponse::InternalServerError).attach_printable("Failed to encode billing address")?.map(masking::Secret::new),
customer_details: None,
},
),
),
common_utils::types::keymanager::Identifier::Merchant(platform.get_processor().get_account().get_id().to_owned()),
platform.get_processor().get_key_store().key.peek(),
)
.await
.and_then(|val| val.try_into_batchoperation())
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed while encrypting payment intent details".to_string())?;
let encrypted_data =
hyperswitch_domain_models::payments::FromRequestEncryptablePaymentIntent::from_encryptable(batch_encrypted_data)
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed while encrypting payment intent details")?;
let payment_intent_domain =
hyperswitch_domain_models::payments::PaymentIntent::create_domain_model_from_request(
payment_id,
platform,
profile,
request.clone(),
encrypted_data,
cell_id,
)
.await?;
let payment_intent = db
.insert_payment_intent(
payment_intent_domain,
platform.get_processor().get_key_store(),
storage_scheme,
)
.await
.to_duplicate_response(errors::ApiErrorResponse::GenericDuplicateError {
message: format!(
"Payment Intent with payment_id {} already exists",
payment_id.get_string_repr()
),
})
.attach_printable("failed while inserting new payment intent")?;
let client_secret = helpers::create_client_secret(
state,
platform.get_processor().get_account().get_id(),
authentication::ResourceId::Payment(payment_id.clone()),
)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Unable to create client secret")?;
let payment_data = payments::PaymentIntentData {
flow: PhantomData,
payment_intent,
client_secret: Some(client_secret.secret),
sessions_token: vec![],
vault_session_details: None,
connector_customer_id: None,
};
let get_trackers_response = operations::GetTrackerResponse { payment_data };
Ok(get_trackers_response)
}
}
#[async_trait]
impl<F: Clone + Sync> UpdateTracker<F, payments::PaymentIntentData<F>, PaymentsCreateIntentRequest>
for PaymentIntentCreate
{
#[instrument(skip_all)]
async fn update_trackers<'b>(
&'b self,
_state: &'b SessionState,
_req_state: ReqState,
_processor: &domain::Processor,
payment_data: payments::PaymentIntentData<F>,
_customer: Option<domain::Customer>,
_frm_suggestion: Option<FrmSuggestion>,
_header_payload: hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<(
PaymentsCreateIntentOperation<'b, F>,
payments::PaymentIntentData<F>,
)>
where
F: 'b + Send,
{
Ok((Box::new(self), payment_data))
}
}
impl<F: Send + Clone>
ValidateRequest<F, PaymentsCreateIntentRequest, payments::PaymentIntentData<F>>
for PaymentIntentCreate
{
#[instrument(skip_all)]
fn validate_request<'a, 'b>(
&'b self,
_request: &PaymentsCreateIntentRequest,
platform: &'a domain::Platform,
) -> RouterResult<operations::ValidateResult> {
Ok(operations::ValidateResult {
merchant_id: platform.get_processor().get_account().get_id().to_owned(),
storage_scheme: platform.get_processor().get_account().storage_scheme,
requeue: false,
})
}
}
#[async_trait]
impl<F: Clone + Send + Sync> Domain<F, PaymentsCreateIntentRequest, payments::PaymentIntentData<F>>
for PaymentIntentCreate
{
#[instrument(skip_all)]
async fn get_customer_details<'a>(
&'a self,
state: &SessionState,
payment_data: &mut payments::PaymentIntentData<F>,
merchant_key_store: &domain::MerchantKeyStore,
storage_scheme: enums::MerchantStorageScheme,
) -> CustomResult<
(
BoxedOperation<'a, F, PaymentsCreateIntentRequest, payments::PaymentIntentData<F>>,
Option<domain::Customer>,
),
errors::StorageError,
> {
// validate customer_id if sent in the request
if let Some(id) = payment_data.payment_intent.customer_id.clone() {
state
.store
.find_customer_by_global_id(&id, merchant_key_store, storage_scheme)
.await?;
}
Ok((Box::new(self), None))
}
#[instrument(skip_all)]
async fn make_pm_data<'a>(
&'a self,
_state: &'a SessionState,
_payment_data: &mut payments::PaymentIntentData<F>,
_storage_scheme: enums::MerchantStorageScheme,
_merchant_key_store: &domain::MerchantKeyStore,
_customer: &Option<domain::Customer>,
_business_profile: &domain::Profile,
_should_retry_with_pan: bool,
) -> RouterResult<(
PaymentsCreateIntentOperation<'a, F>,
Option<domain::PaymentMethodData>,
Option<String>,
)> {
Ok((Box::new(self), None, None))
}
#[instrument(skip_all)]
async fn perform_routing<'a>(
&'a self,
platform: &domain::Platform,
business_profile: &domain::Profile,
state: &SessionState,
// TODO: do not take the whole payment data here
payment_data: &mut payments::PaymentIntentData<F>,
) -> CustomResult<api::ConnectorCallType, errors::ApiErrorResponse> {
Ok(api::ConnectorCallType::Skip)
}
#[instrument(skip_all)]
async fn guard_payment_against_blocklist<'a>(
&'a self,
_state: &SessionState,
_platform: &domain::Platform,
_payment_data: &mut payments::PaymentIntentData<F>,
) -> CustomResult<bool, errors::ApiErrorResponse> {
Ok(false)
}
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/payments/operations/payment_cancel.rs | crates/router/src/core/payments/operations/payment_cancel.rs | use std::marker::PhantomData;
use api_models::enums::FrmSuggestion;
use async_trait::async_trait;
use common_utils::ext_traits::AsyncExt;
use error_stack::ResultExt;
use router_env::{instrument, tracing};
use super::{BoxedOperation, Domain, GetTracker, Operation, UpdateTracker, ValidateRequest};
use crate::{
core::{
errors::{self, RouterResult, StorageErrorExt},
payments::{helpers, operations, PaymentData},
},
events::audit_events::{AuditEvent, AuditEventType},
routes::{app::ReqState, SessionState},
services,
types::{
self as core_types,
api::{self, PaymentIdTypeExt},
domain,
storage::{self, enums},
},
utils::OptionExt,
};
#[derive(Debug, Clone, Copy, router_derive::PaymentOperation)]
#[operation(operations = "all", flow = "cancel")]
pub struct PaymentCancel;
type PaymentCancelOperation<'b, F> =
BoxedOperation<'b, F, api::PaymentsCancelRequest, PaymentData<F>>;
#[async_trait]
impl<F: Send + Clone + Sync> GetTracker<F, PaymentData<F>, api::PaymentsCancelRequest>
for PaymentCancel
{
#[instrument(skip_all)]
async fn get_trackers<'a>(
&'a self,
state: &'a SessionState,
payment_id: &api::PaymentIdType,
request: &api::PaymentsCancelRequest,
platform: &domain::Platform,
_auth_flow: services::AuthFlow,
_header_payload: &hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<
operations::GetTrackerResponse<'a, F, api::PaymentsCancelRequest, PaymentData<F>>,
> {
let db = &*state.store;
let merchant_id = platform.get_processor().get_account().get_id();
let storage_scheme = platform.get_processor().get_account().storage_scheme;
let payment_id = payment_id
.get_payment_intent_id()
.change_context(errors::ApiErrorResponse::PaymentNotFound)?;
let payment_intent = db
.find_payment_intent_by_payment_id_merchant_id(
&payment_id,
merchant_id,
platform.get_processor().get_key_store(),
storage_scheme,
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
helpers::validate_payment_status_against_not_allowed_statuses(
payment_intent.status,
&[
enums::IntentStatus::Failed,
enums::IntentStatus::Succeeded,
enums::IntentStatus::Cancelled,
enums::IntentStatus::Processing,
enums::IntentStatus::RequiresMerchantAction,
],
"cancel",
)?;
let mut payment_attempt = db
.find_payment_attempt_by_payment_id_merchant_id_attempt_id(
&payment_intent.payment_id,
merchant_id,
payment_intent.active_attempt.get_id().as_str(),
storage_scheme,
platform.get_processor().get_key_store(),
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
let shipping_address = helpers::get_address_by_id(
state,
payment_intent.shipping_address_id.clone(),
platform.get_processor().get_key_store(),
&payment_intent.payment_id,
merchant_id,
platform.get_processor().get_account().storage_scheme,
)
.await?;
let billing_address = helpers::get_address_by_id(
state,
payment_intent.billing_address_id.clone(),
platform.get_processor().get_key_store(),
&payment_intent.payment_id,
merchant_id,
platform.get_processor().get_account().storage_scheme,
)
.await?;
let payment_method_billing = helpers::get_address_by_id(
state,
payment_attempt.payment_method_billing_address_id.clone(),
platform.get_processor().get_key_store(),
&payment_intent.payment_id,
merchant_id,
platform.get_processor().get_account().storage_scheme,
)
.await?;
let currency = payment_attempt.currency.get_required_value("currency")?;
let amount = payment_attempt.get_total_amount().into();
payment_attempt
.cancellation_reason
.clone_from(&request.cancellation_reason);
let creds_identifier = request
.merchant_connector_details
.as_ref()
.map(|mcd| mcd.creds_identifier.to_owned());
request
.merchant_connector_details
.to_owned()
.async_map(|mcd| async {
helpers::insert_merchant_connector_creds_to_config(
db,
platform.get_processor(),
mcd,
)
.await
})
.await
.transpose()?;
let profile_id = payment_intent
.profile_id
.as_ref()
.get_required_value("profile_id")
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("'profile_id' not set in payment intent")?;
let business_profile = db
.find_business_profile_by_profile_id(
platform.get_processor().get_key_store(),
profile_id,
)
.await
.to_not_found_response(errors::ApiErrorResponse::ProfileNotFound {
id: profile_id.get_string_repr().to_owned(),
})?;
let payment_data = PaymentData {
flow: PhantomData,
payment_intent,
payment_attempt,
currency,
amount,
email: None,
mandate_id: None,
mandate_connector: None,
setup_mandate: None,
customer_acceptance: None,
token: None,
token_data: None,
address: core_types::PaymentAddress::new(
shipping_address.as_ref().map(From::from),
billing_address.as_ref().map(From::from),
payment_method_billing.as_ref().map(From::from),
business_profile.use_billing_as_payment_method_billing,
),
confirm: None,
payment_method_data: None,
payment_method_token: None,
payment_method_info: None,
force_sync: None,
all_keys_required: None,
refunds: vec![],
disputes: vec![],
attempts: None,
sessions_token: vec![],
card_cvc: None,
creds_identifier,
pm_token: None,
connector_customer_id: None,
recurring_mandate_payment_data: None,
multiple_capture_data: None,
redirect_response: None,
surcharge_details: None,
frm_message: None,
payment_link_data: None,
incremental_authorization_details: None,
authorizations: vec![],
authentication: None,
recurring_details: None,
poll_config: None,
tax_data: None,
session_id: None,
service_details: None,
card_testing_guard_data: None,
vault_operation: None,
threeds_method_comp_ind: None,
whole_connector_response: None,
is_manual_retry_enabled: None,
is_l2_l3_enabled: false,
external_authentication_data: None,
};
let get_trackers_response = operations::GetTrackerResponse {
operation: Box::new(self),
customer_details: None,
payment_data,
business_profile,
mandate_type: None,
};
Ok(get_trackers_response)
}
}
#[async_trait]
impl<F: Clone + Sync> UpdateTracker<F, PaymentData<F>, api::PaymentsCancelRequest>
for PaymentCancel
{
#[instrument(skip_all)]
async fn update_trackers<'b>(
&'b self,
state: &'b SessionState,
req_state: ReqState,
processor: &domain::Processor,
mut payment_data: PaymentData<F>,
_customer: Option<domain::Customer>,
_frm_suggestion: Option<FrmSuggestion>,
_header_payload: hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<(PaymentCancelOperation<'b, F>, PaymentData<F>)>
where
F: 'b + Send,
{
let storage_scheme = processor.get_account().storage_scheme;
let key_store = processor.get_key_store();
let cancellation_reason = payment_data.payment_attempt.cancellation_reason.clone();
let (intent_status_update, attempt_status_update) =
if payment_data.payment_intent.status != enums::IntentStatus::RequiresCapture {
let payment_intent_update = storage::PaymentIntentUpdate::PGStatusUpdate {
status: enums::IntentStatus::Cancelled,
updated_by: storage_scheme.to_string(),
incremental_authorization_allowed: None,
feature_metadata: payment_data
.payment_intent
.feature_metadata
.clone()
.map(masking::Secret::new),
};
(Some(payment_intent_update), enums::AttemptStatus::Voided)
} else {
(None, enums::AttemptStatus::VoidInitiated)
};
if let Some(payment_intent_update) = intent_status_update {
payment_data.payment_intent = state
.store
.update_payment_intent(
payment_data.payment_intent,
payment_intent_update,
key_store,
storage_scheme,
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
}
state
.store
.update_payment_attempt_with_attempt_id(
payment_data.payment_attempt.clone(),
storage::PaymentAttemptUpdate::VoidUpdate {
status: attempt_status_update,
cancellation_reason: cancellation_reason.clone(),
updated_by: storage_scheme.to_string(),
},
storage_scheme,
key_store,
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
req_state
.event_context
.event(AuditEvent::new(AuditEventType::PaymentCancelled {
cancellation_reason,
}))
.with(payment_data.to_event())
.emit();
Ok((Box::new(self), payment_data))
}
}
impl<F: Send + Clone + Sync> ValidateRequest<F, api::PaymentsCancelRequest, PaymentData<F>>
for PaymentCancel
{
#[instrument(skip_all)]
fn validate_request<'a, 'b>(
&'b self,
request: &api::PaymentsCancelRequest,
processor: &'a domain::Processor,
) -> RouterResult<(PaymentCancelOperation<'b, F>, operations::ValidateResult)> {
Ok((
Box::new(self),
operations::ValidateResult {
merchant_id: processor.get_account().get_id().to_owned(),
payment_id: api::PaymentIdType::PaymentIntentId(request.payment_id.to_owned()),
storage_scheme: processor.get_account().storage_scheme,
requeue: false,
},
))
}
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/payments/operations/payment_create.rs | crates/router/src/core/payments/operations/payment_create.rs | use std::marker::PhantomData;
use api_models::{
enums::FrmSuggestion, mandates::RecurringDetails, payment_methods::PaymentMethodsData,
payments::GetAddressFromPaymentMethodData,
};
use async_trait::async_trait;
use common_types::payments as common_payments_types;
use common_utils::{
ext_traits::{AsyncExt, Encode, ValueExt},
type_name,
types::{
keymanager::{Identifier, KeyManagerState, ToEncryptable},
MinorUnit,
},
};
use diesel_models::payment_attempt::ConnectorMandateReferenceId as DieselConnectorMandateReferenceId;
use error_stack::{self, ResultExt};
use hyperswitch_domain_models::{
mandates::MandateDetails,
payments::{
payment_attempt::PaymentAttempt, payment_intent::CustomerData,
FromRequestEncryptablePaymentIntent,
},
};
use masking::{ExposeInterface, PeekInterface, Secret};
use router_derive::PaymentOperation;
use router_env::{instrument, logger, tracing};
use storage_impl::platform_wrapper;
use time::PrimitiveDateTime;
use super::{BoxedOperation, Domain, GetTracker, Operation, UpdateTracker, ValidateRequest};
use crate::{
consts,
core::{
errors::{self, CustomResult, RouterResult, StorageErrorExt},
mandate::helpers as m_helpers,
payment_link,
payment_methods::cards::create_encrypted_data,
payments::{self, helpers, operations, CustomerDetails, PaymentAddress, PaymentData},
utils as core_utils,
},
db::StorageInterface,
events::audit_events::{AuditEvent, AuditEventType},
routes::{app::ReqState, SessionState},
services,
types::{
self,
api::{self, ConnectorCallType, PaymentIdTypeExt},
domain,
storage::{
self,
enums::{self, IntentStatus},
},
transformers::{ForeignFrom, ForeignTryFrom},
},
utils::{self, OptionExt},
};
#[derive(Debug, Clone, Copy, PaymentOperation)]
#[operation(operations = "all", flow = "authorize")]
pub struct PaymentCreate;
type PaymentCreateOperation<'a, F> = BoxedOperation<'a, F, api::PaymentsRequest, PaymentData<F>>;
/// The `get_trackers` function for `PaymentsCreate` is an entrypoint for new payments
/// This will create all the entities required for a new payment from the request
#[async_trait]
impl<F: Send + Clone + Sync> GetTracker<F, PaymentData<F>, api::PaymentsRequest> for PaymentCreate {
#[instrument(skip_all)]
async fn get_trackers<'a>(
&'a self,
state: &'a SessionState,
payment_id: &api::PaymentIdType,
request: &api::PaymentsRequest,
platform: &domain::Platform,
_auth_flow: services::AuthFlow,
header_payload: &hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<operations::GetTrackerResponse<'a, F, api::PaymentsRequest, PaymentData<F>>>
{
let db = &*state.store;
let money @ (amount, currency) = payments_create_request_validation(request)?;
let payment_id = payment_id
.get_payment_intent_id()
.change_context(errors::ApiErrorResponse::PaymentNotFound)?;
#[cfg(feature = "v1")]
helpers::validate_business_details(
request.business_country,
request.business_label.as_ref(),
platform.get_processor(),
)?;
// If profile id is not passed, get it from the business_country and business_label
#[cfg(feature = "v1")]
let profile_id = core_utils::get_profile_id_from_business_details(
request.business_country,
request.business_label.as_ref(),
platform.get_processor(),
request.profile_id.as_ref(),
&*state.store,
true,
)
.await?;
// Profile id will be mandatory in v2 in the request / headers
#[cfg(feature = "v2")]
let profile_id = request
.profile_id
.clone()
.get_required_value("profile_id")
.attach_printable("Profile id is a mandatory parameter")?;
// TODO: eliminate a redundant db call to fetch the business profile
// Validate whether profile_id passed in request is valid and is linked to the merchant
let business_profile = if let Some(business_profile) =
core_utils::validate_and_get_business_profile(
db,
platform.get_processor(),
Some(&profile_id),
)
.await?
{
business_profile
} else {
platform_wrapper::business_profile::find_business_profile_by_profile_id(
state.store.as_ref(),
platform.get_processor(),
&profile_id,
)
.await
.to_not_found_response(errors::ApiErrorResponse::ProfileNotFound {
id: profile_id.get_string_repr().to_owned(),
})?
};
let customer_acceptance = request.customer_acceptance.clone();
let recurring_details = request.recurring_details.clone();
let mandate_type = m_helpers::get_mandate_type(
request.mandate_data.clone(),
request.off_session,
request.setup_future_usage,
request.customer_acceptance.clone(),
request.payment_token.clone(),
request.payment_method,
)
.change_context(errors::ApiErrorResponse::MandateValidationFailed {
reason: "Expected one out of recurring_details and mandate_data but got both".into(),
})?;
let m_helpers::MandateGenericData {
token,
payment_method,
payment_method_type,
mandate_data,
recurring_mandate_payment_data,
mandate_connector,
payment_method_info,
} = helpers::get_token_pm_type_mandate_details(
state,
request,
mandate_type,
platform,
None,
None,
)
.await?;
helpers::validate_allowed_payment_method_types_request(
state,
&profile_id,
platform.get_processor(),
request.allowed_payment_method_types.clone(),
)
.await?;
let customer_details = helpers::get_customer_details_from_request(request);
let shipping_address = helpers::create_or_find_address_for_payment_by_request(
state,
request.shipping.as_ref(),
None,
platform.get_processor().get_account().get_id(),
customer_details.customer_id.as_ref(),
platform.get_processor().get_key_store(),
&payment_id,
platform.get_processor().get_account().storage_scheme,
)
.await?;
let billing_address = helpers::create_or_find_address_for_payment_by_request(
state,
request.billing.as_ref(),
None,
platform.get_processor().get_account().get_id(),
customer_details.customer_id.as_ref(),
platform.get_processor().get_key_store(),
&payment_id,
platform.get_processor().get_account().storage_scheme,
)
.await?;
let payment_method_billing_address =
helpers::create_or_find_address_for_payment_by_request(
state,
request
.payment_method_data
.as_ref()
.and_then(|pmd| pmd.billing.as_ref()),
None,
platform.get_processor().get_account().get_id(),
customer_details.customer_id.as_ref(),
platform.get_processor().get_key_store(),
&payment_id,
platform.get_processor().get_account().storage_scheme,
)
.await?;
let browser_info = request
.browser_info
.clone()
.as_ref()
.map(Encode::encode_to_value)
.transpose()
.change_context(errors::ApiErrorResponse::InvalidDataValue {
field_name: "browser_info",
})?;
let attempt_id = if core_utils::is_merchant_enabled_for_payment_id_as_connector_request_id(
&state.conf,
platform.get_processor(),
) {
payment_id.get_string_repr().to_string()
} else {
payment_id.get_attempt_id(1)
};
let session_expiry =
common_utils::date_time::now().saturating_add(time::Duration::seconds(
request.session_expiry.map(i64::from).unwrap_or(
business_profile
.session_expiry
.unwrap_or(consts::DEFAULT_SESSION_EXPIRY),
),
));
let payment_link_data = match request.payment_link {
Some(true) => {
let default_domain_name = state.base_url.clone();
let (payment_link_config, domain_name) =
payment_link::get_payment_link_config_based_on_priority(
request.payment_link_config.clone(),
business_profile.payment_link_config.clone(),
platform.get_processor(),
default_domain_name,
request.payment_link_config_id.clone(),
)?;
create_payment_link(
request,
payment_link_config,
platform.get_processor(),
payment_id.clone(),
db,
amount,
request.description.clone(),
profile_id.clone(),
domain_name,
session_expiry,
header_payload.locale.clone(),
)
.await?
}
_ => None,
};
let payment_intent_new = Self::make_payment_intent(
state,
&payment_id,
platform,
money,
request,
shipping_address
.as_ref()
.map(|address| address.address_id.clone()),
payment_link_data.clone(),
billing_address
.as_ref()
.map(|address| address.address_id.clone()),
attempt_id,
profile_id.clone(),
session_expiry,
&business_profile,
request.is_payment_id_from_merchant,
)
.await?;
let (payment_attempt_new, additional_payment_data) = Self::make_payment_attempt(
&payment_id,
platform,
money,
payment_method,
payment_method_type,
request,
browser_info,
state,
payment_method_billing_address
.as_ref()
.map(|address| address.address_id.clone()),
&payment_method_info,
profile_id,
&customer_acceptance,
)
.await?;
let payment_intent = platform_wrapper::payment_intent::insert_payment_intent(
state.store.as_ref(),
platform.get_processor(),
payment_intent_new,
)
.await
.to_duplicate_response(errors::ApiErrorResponse::DuplicatePayment {
payment_id: payment_id.clone(),
})?;
if let Some(order_details) = &request.order_details {
helpers::validate_order_details_amount(
order_details.to_owned(),
payment_intent.amount,
false,
)?;
}
#[cfg(feature = "v1")]
let mut payment_attempt = platform_wrapper::payment_attempt::insert_payment_attempt(
state.store.as_ref(),
platform.get_processor(),
payment_attempt_new,
)
.await
.to_duplicate_response(errors::ApiErrorResponse::DuplicatePayment {
payment_id: payment_id.clone(),
})?;
#[cfg(feature = "v2")]
let payment_attempt = platform_wrapper::payment_attempt::insert_payment_attempt(
state.store.as_ref(),
platform.get_processor(),
payment_attempt_new,
)
.await
.to_duplicate_response(errors::ApiErrorResponse::DuplicatePayment {
payment_id: payment_id.clone(),
})?;
let mandate_details_present = payment_attempt.mandate_details.is_some();
helpers::validate_mandate_data_and_future_usage(
request.setup_future_usage,
mandate_details_present,
)?;
// connector mandate reference update history
let mandate_id = request
.mandate_id
.as_ref()
.or_else(|| {
request.recurring_details
.as_ref()
.and_then(|recurring_details| match recurring_details {
RecurringDetails::MandateId(id) => Some(id),
_ => None,
})
})
.async_and_then(|mandate_id| async {
let mandate = db
.find_mandate_by_merchant_id_mandate_id(platform.get_processor().get_account().get_id(), mandate_id, platform.get_processor().get_account().storage_scheme)
.await
.to_not_found_response(errors::ApiErrorResponse::MandateNotFound);
Some(mandate.and_then(|mandate_obj| {
match (
mandate_obj.network_transaction_id,
mandate_obj.connector_mandate_ids,
) {
(_, Some(connector_mandate_id)) => connector_mandate_id
.parse_value("ConnectorMandateId")
.change_context(errors::ApiErrorResponse::MandateNotFound)
.map(|connector_id: api_models::payments::ConnectorMandateReferenceId| {
api_models::payments::MandateIds {
mandate_id: Some(mandate_obj.mandate_id),
mandate_reference_id: Some(api_models::payments::MandateReferenceId::ConnectorMandateId(
api_models::payments::ConnectorMandateReferenceId::new(
connector_id.get_connector_mandate_id(),
connector_id.get_payment_method_id(),
None,
None,
connector_id.get_connector_mandate_request_reference_id(),
None
)
))
}
}),
(Some(network_tx_id), _) => Ok(api_models::payments::MandateIds {
mandate_id: Some(mandate_obj.mandate_id),
mandate_reference_id: Some(
api_models::payments::MandateReferenceId::NetworkMandateId(
network_tx_id,
),
),
}),
(_, _) => Ok(api_models::payments::MandateIds {
mandate_id: Some(mandate_obj.mandate_id),
mandate_reference_id: None,
}),
}
}))
})
.await
.transpose()?;
let mandate_id = if mandate_id.is_none() {
request
.recurring_details
.as_ref()
.and_then(|recurring_details| match recurring_details {
RecurringDetails::ProcessorPaymentToken(token) => {
Some(api_models::payments::MandateIds {
mandate_id: None,
mandate_reference_id: Some(
api_models::payments::MandateReferenceId::ConnectorMandateId(
api_models::payments::ConnectorMandateReferenceId::new(
Some(token.processor_payment_token.clone()),
None,
None,
None,
None,
None,
),
),
),
})
}
_ => None,
})
} else {
mandate_id
};
let operation = payments::if_not_create_change_operation::<_, F>(
payment_intent.status,
request.confirm,
self,
);
let creds_identifier = request
.merchant_connector_details
.as_ref()
.map(|mcd| mcd.creds_identifier.to_owned());
request
.merchant_connector_details
.to_owned()
.async_map(|mcd| async {
helpers::insert_merchant_connector_creds_to_config(
db,
platform.get_processor(),
mcd,
)
.await
})
.await
.transpose()?;
// The operation merges mandate data from both request and payment_attempt
let setup_mandate = mandate_data;
let surcharge_details = request.surcharge_details.map(|request_surcharge_details| {
payments::types::SurchargeDetails::from((&request_surcharge_details, &payment_attempt))
});
let payment_method_data_after_card_bin_call = request
.payment_method_data
.as_ref()
.and_then(|payment_method_data_from_request| {
payment_method_data_from_request
.payment_method_data
.as_ref()
})
.zip(additional_payment_data)
.map(|(payment_method_data, additional_payment_data)| {
payment_method_data.apply_additional_payment_data(additional_payment_data)
})
.transpose()
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Card cobadge check failed due to an invalid card network regex")?;
let additional_pm_data_from_locker = if let Some(ref pm) = payment_method_info {
let card_detail_from_locker: Option<api::CardDetailFromLocker> = pm
.payment_method_data
.clone()
.map(|x| x.into_inner().expose())
.and_then(|v| {
v.parse_value("PaymentMethodsData")
.map_err(|err| {
router_env::logger::info!(
"PaymentMethodsData deserialization failed: {:?}",
err
)
})
.ok()
})
.and_then(|pmd| match pmd {
PaymentMethodsData::Card(crd) => Some(api::CardDetailFromLocker::from(crd)),
_ => None,
});
card_detail_from_locker.map(|card_details| {
let additional_data = card_details.into();
api_models::payments::AdditionalPaymentData::Card(Box::new(additional_data))
})
} else {
None
};
// Only set `payment_attempt.payment_method_data` if `additional_pm_data_from_locker` is not None
if let Some(additional_pm_data) = additional_pm_data_from_locker.as_ref() {
payment_attempt.payment_method_data = Some(
Encode::encode_to_value(additional_pm_data)
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed to encode additional pm data")?,
);
}
let amount = payment_attempt.get_total_amount().into();
payment_attempt.connector_mandate_detail =
Some(DieselConnectorMandateReferenceId::foreign_from(
api_models::payments::ConnectorMandateReferenceId::new(
None,
None,
None, // update_history
None, // mandate_metadata
Some(common_utils::generate_id_with_len(
consts::CONNECTOR_MANDATE_REQUEST_REFERENCE_ID_LENGTH,
)), // connector_mandate_request_reference_id
None,
),
));
let address = PaymentAddress::new(
shipping_address.as_ref().map(From::from),
billing_address.as_ref().map(From::from),
payment_method_billing_address.as_ref().map(From::from),
business_profile.use_billing_as_payment_method_billing,
);
let payment_method_data_billing = request
.payment_method_data
.as_ref()
.and_then(|pmd| pmd.payment_method_data.as_ref())
.and_then(|payment_method_data_billing| {
payment_method_data_billing.get_billing_address()
})
.map(From::from);
let unified_address =
address.unify_with_payment_method_data_billing(payment_method_data_billing);
let payment_data = PaymentData {
flow: PhantomData,
payment_intent,
payment_attempt,
currency,
amount,
email: request.email.clone(),
mandate_id: mandate_id.clone(),
mandate_connector,
setup_mandate,
customer_acceptance,
token,
address: unified_address,
token_data: None,
confirm: request.confirm,
payment_method_data: payment_method_data_after_card_bin_call.map(Into::into),
payment_method_token: None,
payment_method_info,
refunds: vec![],
disputes: vec![],
attempts: None,
force_sync: None,
all_keys_required: None,
sessions_token: vec![],
card_cvc: request.card_cvc.clone(),
creds_identifier,
pm_token: None,
connector_customer_id: None,
recurring_mandate_payment_data,
multiple_capture_data: None,
redirect_response: None,
surcharge_details,
frm_message: None,
payment_link_data,
incremental_authorization_details: None,
authorizations: vec![],
authentication: None,
recurring_details,
poll_config: None,
tax_data: None,
session_id: None,
service_details: None,
card_testing_guard_data: None,
vault_operation: None,
threeds_method_comp_ind: None,
whole_connector_response: None,
is_manual_retry_enabled: None,
is_l2_l3_enabled: business_profile.is_l2_l3_enabled,
external_authentication_data: request.three_ds_data.clone(),
};
let get_trackers_response = operations::GetTrackerResponse {
operation,
customer_details: Some(customer_details),
payment_data,
business_profile,
mandate_type,
};
Ok(get_trackers_response)
}
}
#[async_trait]
impl<F: Clone + Send + Sync> Domain<F, api::PaymentsRequest, PaymentData<F>> for PaymentCreate {
#[instrument(skip_all)]
async fn populate_raw_customer_details<'a>(
&'a self,
state: &SessionState,
payment_data: &mut PaymentData<F>,
request: Option<&CustomerDetails>,
processor: &domain::Processor,
) -> CustomResult<(), errors::StorageError> {
helpers::populate_raw_customer_details(state, payment_data, request, processor).await
}
#[instrument(skip_all)]
async fn get_or_create_customer_details<'a>(
&'a self,
state: &SessionState,
payment_data: &mut PaymentData<F>,
request: Option<CustomerDetails>,
provider: &domain::Provider,
) -> CustomResult<(PaymentCreateOperation<'a, F>, Option<domain::Customer>), errors::StorageError>
{
match provider.get_account().merchant_account_type {
common_enums::MerchantAccountType::Standard => {
helpers::create_customer_if_not_exist(
state,
Box::new(self),
payment_data,
request,
provider,
)
.await
}
common_enums::MerchantAccountType::Platform => {
let customer = helpers::get_customer_if_exists(
state,
request.as_ref().and_then(|r| r.customer_id.as_ref()),
payment_data.payment_intent.customer_id.as_ref(),
provider,
)
.await?
.inspect(|cust| {
payment_data.payment_intent.customer_id = Some(cust.customer_id.clone());
payment_data.email = payment_data
.email
.clone()
.or_else(|| cust.email.clone().map(Into::into));
});
Ok((Box::new(self), customer))
}
common_enums::MerchantAccountType::Connected => {
Err(errors::StorageError::ValueNotFound(
"Connected merchant cannot be a provider".to_string(),
)
.into())
}
}
}
async fn payments_dynamic_tax_calculation<'a>(
&'a self,
state: &SessionState,
payment_data: &mut PaymentData<F>,
_connector_call_type: &ConnectorCallType,
business_profile: &domain::Profile,
platform: &domain::Platform,
) -> CustomResult<(), errors::ApiErrorResponse> {
let is_tax_connector_enabled = business_profile.get_is_tax_connector_enabled();
let skip_external_tax_calculation = payment_data
.payment_intent
.skip_external_tax_calculation
.unwrap_or(false);
if is_tax_connector_enabled && !skip_external_tax_calculation {
let db = state.store.as_ref();
let merchant_connector_id = business_profile
.tax_connector_id
.as_ref()
.get_required_value("business_profile.tax_connector_id")?;
#[cfg(feature = "v1")]
let mca = db
.find_by_merchant_connector_account_merchant_id_merchant_connector_id(
&business_profile.merchant_id,
merchant_connector_id,
platform.get_processor().get_key_store(),
)
.await
.to_not_found_response(
errors::ApiErrorResponse::MerchantConnectorAccountNotFound {
id: merchant_connector_id.get_string_repr().to_string(),
},
)?;
#[cfg(feature = "v2")]
let mca = db
.find_merchant_connector_account_by_id(merchant_connector_id, key_store)
.await
.to_not_found_response(
errors::ApiErrorResponse::MerchantConnectorAccountNotFound {
id: merchant_connector_id.get_string_repr().to_string(),
},
)?;
let connector_data =
api::TaxCalculateConnectorData::get_connector_by_name(&mca.connector_name)?;
let router_data = core_utils::construct_payments_dynamic_tax_calculation_router_data(
state,
platform,
payment_data,
&mca,
)
.await?;
let connector_integration: services::BoxedPaymentConnectorIntegrationInterface<
api::CalculateTax,
types::PaymentsTaxCalculationData,
types::TaxCalculationResponseData,
> = connector_data.connector.get_connector_integration();
let response = services::execute_connector_processing_step(
state,
connector_integration,
&router_data,
payments::CallConnectorAction::Trigger,
None,
None,
)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Tax connector Response Failed")?;
let tax_response = response.response.map_err(|err| {
errors::ApiErrorResponse::ExternalConnectorError {
code: err.code,
message: err.message,
connector: connector_data.connector_name.clone().to_string(),
status_code: err.status_code,
reason: err.reason,
}
})?;
payment_data.payment_intent.tax_details = Some(diesel_models::TaxDetails {
default: Some(diesel_models::DefaultTax {
order_tax_amount: tax_response.order_tax_amount,
}),
payment_method_type: None,
});
Ok(())
} else {
Ok(())
}
}
#[instrument(skip_all)]
async fn make_pm_data<'a>(
&'a self,
state: &'a SessionState,
payment_data: &mut PaymentData<F>,
storage_scheme: enums::MerchantStorageScheme,
merchant_key_store: &domain::MerchantKeyStore,
customer: &Option<domain::Customer>,
business_profile: &domain::Profile,
should_retry_with_pan: bool,
) -> RouterResult<(
PaymentCreateOperation<'a, F>,
Option<domain::PaymentMethodData>,
Option<String>,
)> {
Box::pin(helpers::make_pm_data(
Box::new(self),
state,
payment_data,
merchant_key_store,
customer,
storage_scheme,
business_profile,
should_retry_with_pan,
))
.await
}
#[instrument(skip_all)]
async fn add_task_to_process_tracker<'a>(
&'a self,
_state: &'a SessionState,
_payment_attempt: &PaymentAttempt,
_requeue: bool,
_schedule_time: Option<PrimitiveDateTime>,
) -> CustomResult<(), errors::ApiErrorResponse> {
Ok(())
}
async fn get_connector<'a>(
&'a self,
_platform: &domain::Platform,
state: &SessionState,
request: &api::PaymentsRequest,
_payment_intent: &storage::PaymentIntent,
) -> CustomResult<api::ConnectorChoice, errors::ApiErrorResponse> {
helpers::get_connector_default(state, request.routing.clone()).await
}
#[instrument(skip_all)]
async fn guard_payment_against_blocklist<'a>(
&'a self,
_state: &SessionState,
_platform: &domain::Platform,
_payment_data: &mut PaymentData<F>,
) -> CustomResult<bool, errors::ApiErrorResponse> {
Ok(false)
}
}
#[async_trait]
impl<F: Clone + Sync> UpdateTracker<F, PaymentData<F>, api::PaymentsRequest> for PaymentCreate {
#[instrument(skip_all)]
async fn update_trackers<'b>(
&'b self,
state: &'b SessionState,
req_state: ReqState,
processor: &domain::Processor,
mut payment_data: PaymentData<F>,
customer: Option<domain::Customer>,
_frm_suggestion: Option<FrmSuggestion>,
_header_payload: hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<(PaymentCreateOperation<'b, F>, PaymentData<F>)>
where
F: 'b + Send,
{
let storage_scheme = processor.get_account().storage_scheme;
let key_store = processor.get_key_store();
let status = match payment_data.payment_intent.status {
IntentStatus::RequiresPaymentMethod => match payment_data.payment_method_data {
Some(_) => Some(IntentStatus::RequiresConfirmation),
_ => None,
},
IntentStatus::RequiresConfirmation => {
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | true |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/payments/operations/payment_reject.rs | crates/router/src/core/payments/operations/payment_reject.rs | use std::marker::PhantomData;
use api_models::{enums::FrmSuggestion, payments::PaymentsCancelRequest};
use async_trait::async_trait;
use error_stack::ResultExt;
use router_env::{instrument, tracing};
use super::{BoxedOperation, Domain, GetTracker, Operation, UpdateTracker, ValidateRequest};
use crate::{
core::{
errors::{self, RouterResult, StorageErrorExt},
payments::{helpers, operations, PaymentAddress, PaymentData},
},
events::audit_events::{AuditEvent, AuditEventType},
routes::{app::ReqState, SessionState},
services,
types::{
api::{self, PaymentIdTypeExt},
domain,
storage::{self, enums},
},
utils::OptionExt,
};
#[derive(Debug, Clone, Copy, router_derive::PaymentOperation)]
#[operation(operations = "all", flow = "cancel")]
pub struct PaymentReject;
type PaymentRejectOperation<'b, F> = BoxedOperation<'b, F, PaymentsCancelRequest, PaymentData<F>>;
#[async_trait]
impl<F: Send + Clone + Sync> GetTracker<F, PaymentData<F>, PaymentsCancelRequest>
for PaymentReject
{
#[instrument(skip_all)]
async fn get_trackers<'a>(
&'a self,
state: &'a SessionState,
payment_id: &api::PaymentIdType,
_request: &PaymentsCancelRequest,
platform: &domain::Platform,
_auth_flow: services::AuthFlow,
_header_payload: &hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<operations::GetTrackerResponse<'a, F, PaymentsCancelRequest, PaymentData<F>>>
{
let db = &*state.store;
let merchant_id = platform.get_processor().get_account().get_id();
let storage_scheme = platform.get_processor().get_account().storage_scheme;
let payment_id = payment_id
.get_payment_intent_id()
.change_context(errors::ApiErrorResponse::PaymentNotFound)?;
let payment_intent = db
.find_payment_intent_by_payment_id_merchant_id(
&payment_id,
merchant_id,
platform.get_processor().get_key_store(),
storage_scheme,
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
helpers::validate_payment_status_against_not_allowed_statuses(
payment_intent.status,
&[
enums::IntentStatus::Cancelled,
enums::IntentStatus::Failed,
enums::IntentStatus::Succeeded,
enums::IntentStatus::Processing,
],
"reject",
)?;
let attempt_id = payment_intent.active_attempt.get_id().clone();
let payment_attempt = db
.find_payment_attempt_by_payment_id_merchant_id_attempt_id(
&payment_intent.payment_id,
merchant_id,
attempt_id.clone().as_str(),
storage_scheme,
platform.get_processor().get_key_store(),
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
let shipping_address = helpers::get_address_by_id(
state,
payment_intent.shipping_address_id.clone(),
platform.get_processor().get_key_store(),
&payment_intent.payment_id,
merchant_id,
platform.get_processor().get_account().storage_scheme,
)
.await?;
let billing_address = helpers::get_address_by_id(
state,
payment_intent.billing_address_id.clone(),
platform.get_processor().get_key_store(),
&payment_intent.payment_id,
merchant_id,
platform.get_processor().get_account().storage_scheme,
)
.await?;
let payment_method_billing = helpers::get_address_by_id(
state,
payment_attempt.payment_method_billing_address_id.clone(),
platform.get_processor().get_key_store(),
&payment_intent.payment_id,
merchant_id,
platform.get_processor().get_account().storage_scheme,
)
.await?;
let currency = payment_attempt.currency.get_required_value("currency")?;
let amount = payment_attempt.get_total_amount().into();
let frm_response = if cfg!(feature = "frm") {
db.find_fraud_check_by_payment_id(payment_intent.payment_id.clone(), platform.get_processor().get_account().get_id().clone())
.await
.change_context(errors::ApiErrorResponse::PaymentNotFound)
.attach_printable_lazy(|| {
format!("Error while retrieving frm_response, merchant_id: {:?}, payment_id: {attempt_id}", platform.get_processor().get_account().get_id())
})
.ok()
} else {
None
};
let profile_id = payment_intent
.profile_id
.as_ref()
.get_required_value("profile_id")
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("'profile_id' not set in payment intent")?;
let business_profile = state
.store
.find_business_profile_by_profile_id(
platform.get_processor().get_key_store(),
profile_id,
)
.await
.to_not_found_response(errors::ApiErrorResponse::ProfileNotFound {
id: profile_id.get_string_repr().to_owned(),
})?;
let payment_data = PaymentData {
flow: PhantomData,
payment_intent,
payment_attempt,
currency,
amount,
email: None,
mandate_id: None,
mandate_connector: None,
setup_mandate: None,
customer_acceptance: None,
token: None,
address: PaymentAddress::new(
shipping_address.as_ref().map(From::from),
billing_address.as_ref().map(From::from),
payment_method_billing.as_ref().map(From::from),
business_profile.use_billing_as_payment_method_billing,
),
token_data: None,
confirm: None,
payment_method_data: None,
payment_method_token: None,
payment_method_info: None,
force_sync: None,
all_keys_required: None,
refunds: vec![],
disputes: vec![],
attempts: None,
sessions_token: vec![],
card_cvc: None,
creds_identifier: None,
pm_token: None,
connector_customer_id: None,
recurring_mandate_payment_data: None,
multiple_capture_data: None,
redirect_response: None,
surcharge_details: None,
frm_message: frm_response,
payment_link_data: None,
incremental_authorization_details: None,
authorizations: vec![],
authentication: None,
recurring_details: None,
poll_config: None,
tax_data: None,
session_id: None,
service_details: None,
card_testing_guard_data: None,
vault_operation: None,
threeds_method_comp_ind: None,
whole_connector_response: None,
is_manual_retry_enabled: None,
is_l2_l3_enabled: false,
external_authentication_data: None,
};
let get_trackers_response = operations::GetTrackerResponse {
operation: Box::new(self),
customer_details: None,
payment_data,
business_profile,
mandate_type: None,
};
Ok(get_trackers_response)
}
}
#[async_trait]
impl<F: Clone + Sync> UpdateTracker<F, PaymentData<F>, PaymentsCancelRequest> for PaymentReject {
#[instrument(skip_all)]
async fn update_trackers<'b>(
&'b self,
state: &'b SessionState,
req_state: ReqState,
processor: &domain::Processor,
mut payment_data: PaymentData<F>,
_customer: Option<domain::Customer>,
_should_decline_transaction: Option<FrmSuggestion>,
_header_payload: hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<(PaymentRejectOperation<'b, F>, PaymentData<F>)>
where
F: 'b + Send,
{
let storage_scheme = processor.get_account().storage_scheme;
let key_store = processor.get_key_store();
let intent_status_update = storage::PaymentIntentUpdate::RejectUpdate {
status: enums::IntentStatus::Failed,
merchant_decision: Some(enums::MerchantDecision::Rejected.to_string()),
updated_by: storage_scheme.to_string(),
};
let (error_code, error_message) =
payment_data
.frm_message
.clone()
.map_or((None, None), |fraud_check| {
(
Some(Some(fraud_check.frm_status.to_string())),
Some(fraud_check.frm_reason.map(|reason| reason.to_string())),
)
});
let attempt_status_update = storage::PaymentAttemptUpdate::RejectUpdate {
status: enums::AttemptStatus::Failure,
error_code,
error_message,
updated_by: storage_scheme.to_string(),
};
payment_data.payment_intent = state
.store
.update_payment_intent(
payment_data.payment_intent,
intent_status_update,
key_store,
storage_scheme,
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
payment_data.payment_attempt = state
.store
.update_payment_attempt_with_attempt_id(
payment_data.payment_attempt.clone(),
attempt_status_update,
storage_scheme,
key_store,
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
let error_code = payment_data.payment_attempt.error_code.clone();
let error_message = payment_data.payment_attempt.error_message.clone();
req_state
.event_context
.event(AuditEvent::new(AuditEventType::PaymentReject {
error_code,
error_message,
}))
.with(payment_data.to_event())
.emit();
Ok((Box::new(self), payment_data))
}
}
impl<F: Send + Clone + Sync> ValidateRequest<F, PaymentsCancelRequest, PaymentData<F>>
for PaymentReject
{
#[instrument(skip_all)]
fn validate_request<'a, 'b>(
&'b self,
request: &PaymentsCancelRequest,
processor: &'a domain::Processor,
) -> RouterResult<(PaymentRejectOperation<'b, F>, operations::ValidateResult)> {
Ok((
Box::new(self),
operations::ValidateResult {
merchant_id: processor.get_account().get_id().to_owned(),
payment_id: api::PaymentIdType::PaymentIntentId(request.payment_id.to_owned()),
storage_scheme: processor.get_account().storage_scheme,
requeue: false,
},
))
}
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/payments/operations/payment_post_session_tokens.rs | crates/router/src/core/payments/operations/payment_post_session_tokens.rs | use std::marker::PhantomData;
use api_models::enums::FrmSuggestion;
use async_trait::async_trait;
use error_stack::ResultExt;
use masking::PeekInterface;
use router_derive::PaymentOperation;
use router_env::{instrument, tracing};
use super::{BoxedOperation, Domain, GetTracker, Operation, UpdateTracker, ValidateRequest};
use crate::{
core::{
errors::{self, RouterResult, StorageErrorExt},
payments::{self, helpers, operations, PaymentData},
},
routes::{app::ReqState, SessionState},
services,
types::{
api::{self, PaymentIdTypeExt},
domain,
storage::{self, enums as storage_enums},
},
utils::OptionExt,
};
#[derive(Debug, Clone, Copy, PaymentOperation)]
#[operation(operations = "all", flow = "post_session_tokens")]
pub struct PaymentPostSessionTokens;
type PaymentPostSessionTokensOperation<'b, F> =
BoxedOperation<'b, F, api::PaymentsPostSessionTokensRequest, PaymentData<F>>;
#[async_trait]
impl<F: Send + Clone + Sync> GetTracker<F, PaymentData<F>, api::PaymentsPostSessionTokensRequest>
for PaymentPostSessionTokens
{
#[instrument(skip_all)]
async fn get_trackers<'a>(
&'a self,
state: &'a SessionState,
payment_id: &api::PaymentIdType,
request: &api::PaymentsPostSessionTokensRequest,
platform: &domain::Platform,
_auth_flow: services::AuthFlow,
_header_payload: &hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<
operations::GetTrackerResponse<
'a,
F,
api::PaymentsPostSessionTokensRequest,
PaymentData<F>,
>,
> {
let payment_id = payment_id
.get_payment_intent_id()
.change_context(errors::ApiErrorResponse::PaymentNotFound)?;
let db = &*state.store;
let merchant_id = platform.get_processor().get_account().get_id();
let storage_scheme = platform.get_processor().get_account().storage_scheme;
let payment_intent = db
.find_payment_intent_by_payment_id_merchant_id(
&payment_id,
merchant_id,
platform.get_processor().get_key_store(),
storage_scheme,
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
// TODO (#7195): Add platform merchant account validation once publishable key auth is solved
helpers::authenticate_client_secret(Some(request.client_secret.peek()), &payment_intent)?;
let mut payment_attempt = db
.find_payment_attempt_by_payment_id_merchant_id_attempt_id(
&payment_intent.payment_id,
merchant_id,
payment_intent.active_attempt.get_id().as_str(),
storage_scheme,
platform.get_processor().get_key_store(),
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
let currency = payment_intent.currency.get_required_value("currency")?;
let amount = payment_attempt.get_total_amount().into();
let profile_id = payment_intent
.profile_id
.as_ref()
.get_required_value("profile_id")
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("'profile_id' not set in payment intent")?;
let business_profile = db
.find_business_profile_by_profile_id(
platform.get_processor().get_key_store(),
profile_id,
)
.await
.to_not_found_response(errors::ApiErrorResponse::ProfileNotFound {
id: profile_id.get_string_repr().to_owned(),
})?;
payment_attempt.payment_method = Some(request.payment_method);
payment_attempt.payment_method_type = Some(request.payment_method_type);
let shipping_address = helpers::get_address_by_id(
state,
payment_intent.shipping_address_id.clone(),
platform.get_processor().get_key_store(),
&payment_intent.payment_id,
merchant_id,
platform.get_processor().get_account().storage_scheme,
)
.await?;
let billing_address = helpers::get_address_by_id(
state,
payment_intent.billing_address_id.clone(),
platform.get_processor().get_key_store(),
&payment_intent.payment_id,
merchant_id,
platform.get_processor().get_account().storage_scheme,
)
.await?;
let payment_data = PaymentData {
flow: PhantomData,
payment_intent,
payment_attempt,
currency,
amount,
email: None,
mandate_id: None,
mandate_connector: None,
customer_acceptance: None,
token: None,
token_data: None,
setup_mandate: None,
address: payments::PaymentAddress::new(
shipping_address.as_ref().map(From::from),
billing_address.as_ref().map(From::from),
None,
business_profile.use_billing_as_payment_method_billing,
),
confirm: None,
payment_method_data: None,
payment_method_token: None,
payment_method_info: None,
force_sync: None,
all_keys_required: None,
refunds: vec![],
disputes: vec![],
attempts: None,
sessions_token: vec![],
card_cvc: None,
creds_identifier: None,
pm_token: None,
connector_customer_id: None,
recurring_mandate_payment_data: None,
multiple_capture_data: None,
redirect_response: None,
surcharge_details: None,
frm_message: None,
payment_link_data: None,
incremental_authorization_details: None,
authorizations: vec![],
authentication: None,
recurring_details: None,
poll_config: None,
tax_data: None,
session_id: None,
service_details: None,
card_testing_guard_data: None,
vault_operation: None,
threeds_method_comp_ind: None,
whole_connector_response: None,
is_manual_retry_enabled: None,
is_l2_l3_enabled: false,
external_authentication_data: None,
};
let get_trackers_response = operations::GetTrackerResponse {
operation: Box::new(self),
customer_details: None,
payment_data,
business_profile,
mandate_type: None,
};
Ok(get_trackers_response)
}
}
#[async_trait]
impl<F: Clone + Send + Sync> Domain<F, api::PaymentsPostSessionTokensRequest, PaymentData<F>>
for PaymentPostSessionTokens
{
#[instrument(skip_all)]
async fn populate_raw_customer_details<'a>(
&'a self,
_state: &SessionState,
_payment_data: &mut PaymentData<F>,
_request: Option<&payments::CustomerDetails>,
_processor: &domain::Processor,
) -> errors::CustomResult<(), errors::StorageError> {
Ok(())
}
#[instrument(skip_all)]
async fn get_or_create_customer_details<'a>(
&'a self,
_state: &SessionState,
_payment_data: &mut PaymentData<F>,
_request: Option<payments::CustomerDetails>,
_provider: &domain::Provider,
) -> errors::CustomResult<
(
PaymentPostSessionTokensOperation<'a, F>,
Option<domain::Customer>,
),
errors::StorageError,
> {
Ok((Box::new(self), None))
}
#[instrument(skip_all)]
async fn make_pm_data<'a>(
&'a self,
_state: &'a SessionState,
_payment_data: &mut PaymentData<F>,
_storage_scheme: storage_enums::MerchantStorageScheme,
_merchant_key_store: &domain::MerchantKeyStore,
_customer: &Option<domain::Customer>,
_business_profile: &domain::Profile,
_should_retry_with_pan: bool,
) -> RouterResult<(
PaymentPostSessionTokensOperation<'a, F>,
Option<domain::PaymentMethodData>,
Option<String>,
)> {
Ok((Box::new(self), None, None))
}
async fn get_connector<'a>(
&'a self,
_platform: &domain::Platform,
state: &SessionState,
_request: &api::PaymentsPostSessionTokensRequest,
_payment_intent: &storage::PaymentIntent,
) -> errors::CustomResult<api::ConnectorChoice, errors::ApiErrorResponse> {
helpers::get_connector_default(state, None).await
}
#[instrument(skip_all)]
async fn guard_payment_against_blocklist<'a>(
&'a self,
_state: &SessionState,
_platform: &domain::Platform,
_payment_data: &mut PaymentData<F>,
) -> errors::CustomResult<bool, errors::ApiErrorResponse> {
Ok(false)
}
}
#[async_trait]
impl<F: Clone + Sync> UpdateTracker<F, PaymentData<F>, api::PaymentsPostSessionTokensRequest>
for PaymentPostSessionTokens
{
#[instrument(skip_all)]
async fn update_trackers<'b>(
&'b self,
_state: &'b SessionState,
_req_state: ReqState,
_processor: &domain::Processor,
payment_data: PaymentData<F>,
_customer: Option<domain::Customer>,
_frm_suggestion: Option<FrmSuggestion>,
_header_payload: hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<(PaymentPostSessionTokensOperation<'b, F>, PaymentData<F>)>
where
F: 'b + Send,
{
Ok((Box::new(self), payment_data))
}
}
impl<F: Send + Clone + Sync>
ValidateRequest<F, api::PaymentsPostSessionTokensRequest, PaymentData<F>>
for PaymentPostSessionTokens
{
#[instrument(skip_all)]
fn validate_request<'a, 'b>(
&'b self,
request: &api::PaymentsPostSessionTokensRequest,
processor: &'a domain::Processor,
) -> RouterResult<(
PaymentPostSessionTokensOperation<'b, F>,
operations::ValidateResult,
)> {
//payment id is already generated and should be sent in the request
let given_payment_id = request.payment_id.clone();
Ok((
Box::new(self),
operations::ValidateResult {
merchant_id: processor.get_account().get_id().to_owned(),
payment_id: api::PaymentIdType::PaymentIntentId(given_payment_id),
storage_scheme: processor.get_account().storage_scheme,
requeue: false,
},
))
}
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/payments/operations/external_vault_proxy_payment_intent.rs | crates/router/src/core/payments/operations/external_vault_proxy_payment_intent.rs | use api_models::payments::ExternalVaultProxyPaymentsRequest;
use async_trait::async_trait;
use common_enums::enums;
use common_utils::{
crypto::Encryptable,
ext_traits::{AsyncExt, ValueExt},
types::keymanager::ToEncryptable,
};
use error_stack::{report, ResultExt};
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData, payments::PaymentConfirmData,
};
use hyperswitch_interfaces::api::ConnectorSpecifications;
use masking::PeekInterface;
use router_env::{instrument, tracing};
use super::{Domain, GetTracker, Operation, PostUpdateTracker, UpdateTracker, ValidateRequest};
use crate::{
core::{
errors::{self, CustomResult, RouterResult, StorageErrorExt},
payment_methods::{self, PaymentMethodExt},
payments::{
self,
operations::{self, ValidateStatusForOperation},
OperationSessionGetters, OperationSessionSetters,
},
},
routes::{app::ReqState, SessionState},
types::{
self,
api::{self, ConnectorCallType},
domain::{self, types as domain_types},
storage::{self, enums as storage_enums},
},
utils::OptionExt,
};
#[derive(Debug, Clone, Copy)]
pub struct ExternalVaultProxyPaymentIntent;
impl ValidateStatusForOperation for ExternalVaultProxyPaymentIntent {
/// Validate if the current operation can be performed on the current status of the payment intent
fn validate_status_for_operation(
&self,
intent_status: common_enums::IntentStatus,
) -> Result<(), errors::ApiErrorResponse> {
match intent_status {
common_enums::IntentStatus::RequiresPaymentMethod
| common_enums::IntentStatus::Failed
| common_enums::IntentStatus::Processing => Ok(()),
common_enums::IntentStatus::Conflicted
| common_enums::IntentStatus::Succeeded
| common_enums::IntentStatus::Cancelled
| common_enums::IntentStatus::RequiresCustomerAction
| common_enums::IntentStatus::RequiresMerchantAction
| common_enums::IntentStatus::RequiresCapture
| common_enums::IntentStatus::PartiallyCaptured
| common_enums::IntentStatus::RequiresConfirmation
| common_enums::IntentStatus::PartiallyCapturedAndCapturable
| common_enums::IntentStatus::CancelledPostCapture
| common_enums::IntentStatus::PartiallyAuthorizedAndRequiresCapture
| common_enums::IntentStatus::PartiallyCapturedAndProcessing
| common_enums::IntentStatus::Expired => {
Err(errors::ApiErrorResponse::PaymentUnexpectedState {
current_flow: format!("{self:?}"),
field_name: "status".to_string(),
current_value: intent_status.to_string(),
states: ["requires_payment_method", "failed", "processing"].join(", "),
})
}
}
}
}
type BoxedConfirmOperation<'b, F> =
super::BoxedOperation<'b, F, ExternalVaultProxyPaymentsRequest, PaymentConfirmData<F>>;
impl<F: Send + Clone + Sync> Operation<F, ExternalVaultProxyPaymentsRequest>
for &ExternalVaultProxyPaymentIntent
{
type Data = PaymentConfirmData<F>;
fn to_validate_request(
&self,
) -> RouterResult<
&(dyn ValidateRequest<F, ExternalVaultProxyPaymentsRequest, Self::Data> + Send + Sync),
> {
Ok(*self)
}
fn to_get_tracker(
&self,
) -> RouterResult<
&(dyn GetTracker<F, Self::Data, ExternalVaultProxyPaymentsRequest> + Send + Sync),
> {
Ok(*self)
}
fn to_domain(
&self,
) -> RouterResult<&(dyn Domain<F, ExternalVaultProxyPaymentsRequest, Self::Data>)> {
Ok(*self)
}
fn to_update_tracker(
&self,
) -> RouterResult<
&(dyn UpdateTracker<F, Self::Data, ExternalVaultProxyPaymentsRequest> + Send + Sync),
> {
Ok(*self)
}
}
#[automatically_derived]
impl<F: Send + Clone + Sync> Operation<F, ExternalVaultProxyPaymentsRequest>
for ExternalVaultProxyPaymentIntent
{
type Data = PaymentConfirmData<F>;
fn to_validate_request(
&self,
) -> RouterResult<
&(dyn ValidateRequest<F, ExternalVaultProxyPaymentsRequest, Self::Data> + Send + Sync),
> {
Ok(self)
}
fn to_get_tracker(
&self,
) -> RouterResult<
&(dyn GetTracker<F, Self::Data, ExternalVaultProxyPaymentsRequest> + Send + Sync),
> {
Ok(self)
}
fn to_domain(
&self,
) -> RouterResult<&dyn Domain<F, ExternalVaultProxyPaymentsRequest, Self::Data>> {
Ok(self)
}
fn to_update_tracker(
&self,
) -> RouterResult<
&(dyn UpdateTracker<F, Self::Data, ExternalVaultProxyPaymentsRequest> + Send + Sync),
> {
Ok(self)
}
}
impl<F: Send + Clone + Sync>
ValidateRequest<F, ExternalVaultProxyPaymentsRequest, PaymentConfirmData<F>>
for ExternalVaultProxyPaymentIntent
{
#[instrument(skip_all)]
fn validate_request<'a, 'b>(
&'b self,
_request: &ExternalVaultProxyPaymentsRequest,
platform: &'a domain::Platform,
) -> RouterResult<operations::ValidateResult> {
let validate_result = operations::ValidateResult {
merchant_id: platform.get_processor().get_account().get_id().to_owned(),
storage_scheme: platform.get_processor().get_account().storage_scheme,
requeue: false,
};
Ok(validate_result)
}
}
#[async_trait]
impl<F: Send + Clone + Sync> GetTracker<F, PaymentConfirmData<F>, ExternalVaultProxyPaymentsRequest>
for ExternalVaultProxyPaymentIntent
{
#[instrument(skip_all)]
async fn get_trackers<'a>(
&'a self,
state: &'a SessionState,
payment_id: &common_utils::id_type::GlobalPaymentId,
request: &ExternalVaultProxyPaymentsRequest,
platform: &domain::Platform,
_profile: &domain::Profile,
header_payload: &hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<operations::GetTrackerResponse<PaymentConfirmData<F>>> {
let db = &*state.store;
let key_manager_state = &state.into();
let storage_scheme = platform.get_processor().get_account().storage_scheme;
let payment_intent = db
.find_payment_intent_by_id(
payment_id,
platform.get_processor().get_key_store(),
storage_scheme,
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
self.validate_status_for_operation(payment_intent.status)?;
let cell_id = state.conf.cell_information.id.clone();
let batch_encrypted_data = domain_types::crypto_operation(
key_manager_state,
common_utils::type_name!(hyperswitch_domain_models::payments::payment_attempt::PaymentAttempt),
domain_types::CryptoOperation::BatchEncrypt(
hyperswitch_domain_models::payments::payment_attempt::FromRequestEncryptablePaymentAttempt::to_encryptable(
hyperswitch_domain_models::payments::payment_attempt::FromRequestEncryptablePaymentAttempt {
payment_method_billing_address: None,
},
),
),
common_utils::types::keymanager::Identifier::Merchant(platform.get_processor().get_account().get_id().to_owned()),
platform.get_processor().get_key_store().key.peek(),
)
.await
.and_then(|val| val.try_into_batchoperation())
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed while encrypting payment intent details".to_string())?;
let encrypted_data =
hyperswitch_domain_models::payments::payment_attempt::FromRequestEncryptablePaymentAttempt::from_encryptable(batch_encrypted_data)
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed while encrypting payment intent details")?;
let payment_attempt = match payment_intent.active_attempt_id.clone() {
Some(ref active_attempt_id) => db
.find_payment_attempt_by_id(
platform.get_processor().get_key_store(),
active_attempt_id,
storage_scheme,
)
.await
.change_context(errors::ApiErrorResponse::PaymentNotFound)
.attach_printable("Could not find payment attempt")?,
None => {
// TODO: Implement external vault specific payment attempt creation logic
let payment_attempt_domain_model: hyperswitch_domain_models::payments::payment_attempt::PaymentAttempt =
hyperswitch_domain_models::payments::payment_attempt::PaymentAttempt::external_vault_proxy_create_domain_model(
&payment_intent,
cell_id,
storage_scheme,
request,
encrypted_data
)
.await?;
db.insert_payment_attempt(
platform.get_processor().get_key_store(),
payment_attempt_domain_model,
storage_scheme,
)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Could not insert payment attempt")?
}
};
// TODO: Extract external vault specific token/credentials from request
let processor_payment_token = None; // request.external_vault_details.processor_payment_token.clone();
let payment_address = hyperswitch_domain_models::payment_address::PaymentAddress::new(
payment_intent
.shipping_address
.clone()
.map(|address| address.into_inner()),
payment_intent
.billing_address
.clone()
.map(|address| address.into_inner()),
payment_attempt
.payment_method_billing_address
.clone()
.map(|address| address.into_inner()),
Some(true),
);
// TODO: Implement external vault specific mandate data handling
let mandate_data_input = api_models::payments::MandateIds {
mandate_id: None,
mandate_reference_id: processor_payment_token.map(|token| {
api_models::payments::MandateReferenceId::ConnectorMandateId(
api_models::payments::ConnectorMandateReferenceId::new(
Some(token),
None,
None,
None,
None,
None,
),
)
}),
};
let payment_method_data = request.payment_method_data.payment_method_data.clone().map(
hyperswitch_domain_models::payment_method_data::ExternalVaultPaymentMethodData::from,
);
let payment_data = PaymentConfirmData {
flow: std::marker::PhantomData,
payment_intent,
payment_attempt,
payment_method_data: None, // TODO: Review for external vault
payment_address,
mandate_data: Some(mandate_data_input),
payment_method: None,
merchant_connector_details: None,
external_vault_pmd: payment_method_data,
webhook_url: None,
};
let get_trackers_response = operations::GetTrackerResponse { payment_data };
Ok(get_trackers_response)
}
}
#[async_trait]
impl<F: Clone + Send + Sync> Domain<F, ExternalVaultProxyPaymentsRequest, PaymentConfirmData<F>>
for ExternalVaultProxyPaymentIntent
{
async fn get_customer_details<'a>(
&'a self,
state: &SessionState,
payment_data: &mut PaymentConfirmData<F>,
merchant_key_store: &domain::MerchantKeyStore,
storage_scheme: storage_enums::MerchantStorageScheme,
) -> CustomResult<(BoxedConfirmOperation<'a, F>, Option<domain::Customer>), errors::StorageError>
{
match payment_data.payment_intent.customer_id.clone() {
Some(id) => {
let customer = state
.store
.find_customer_by_global_id(&id, merchant_key_store, storage_scheme)
.await?;
Ok((Box::new(self), Some(customer)))
}
None => Ok((Box::new(self), None)),
}
}
#[instrument(skip_all)]
async fn make_pm_data<'a>(
&'a self,
_state: &'a SessionState,
_payment_data: &mut PaymentConfirmData<F>,
_storage_scheme: storage_enums::MerchantStorageScheme,
_key_store: &domain::MerchantKeyStore,
_customer: &Option<domain::Customer>,
_business_profile: &domain::Profile,
_should_retry_with_pan: bool,
) -> RouterResult<(
BoxedConfirmOperation<'a, F>,
Option<PaymentMethodData>,
Option<String>,
)> {
// TODO: Implement external vault specific payment method data creation
Ok((Box::new(self), None, None))
}
async fn create_or_fetch_payment_method<'a>(
&'a self,
state: &SessionState,
platform: &domain::Platform,
business_profile: &domain::Profile,
payment_data: &mut PaymentConfirmData<F>,
) -> CustomResult<(), errors::ApiErrorResponse> {
match (
payment_data.payment_intent.customer_id.clone(),
payment_data.external_vault_pmd.clone(),
payment_data.payment_attempt.customer_acceptance.clone(),
payment_data.payment_attempt.payment_token.clone(),
) {
(Some(customer_id), Some(hyperswitch_domain_models::payment_method_data::ExternalVaultPaymentMethodData::Card(card_details)), Some(_), None) => {
let payment_method_data =
api::PaymentMethodCreateData::ProxyCard(api::ProxyCardDetails::from(*card_details));
let billing = payment_data
.payment_address
.get_payment_method_billing()
.cloned()
.map(From::from);
let req = api::PaymentMethodCreate {
payment_method_type: payment_data.payment_attempt.payment_method_type,
payment_method_subtype: payment_data.payment_attempt.payment_method_subtype,
metadata: None,
customer_id: Some(customer_id),
payment_method_data,
billing,
psp_tokenization: None,
network_tokenization: None,
storage_type: None, //this field is currently not being used in storing payment methods via external vault
};
let (_pm_response, payment_method) = Box::pin(payment_methods::create_payment_method_core(
state,
&state.get_req_state(),
req,
platform,
business_profile,
))
.await?;
payment_data.payment_method = Some(payment_method);
}
(_, Some(hyperswitch_domain_models::payment_method_data::ExternalVaultPaymentMethodData::VaultToken(vault_token)), None, Some(payment_token)) => {
payment_data.external_vault_pmd = Some(payment_methods::get_external_vault_token(
state,
platform.get_processor().get_key_store(),
platform.get_processor().get_account().storage_scheme,
payment_token.clone(),
vault_token.clone(),
&payment_data.payment_attempt.payment_method_type
)
.await?);
}
_ => {
router_env::logger::debug!(
"No payment method to create or fetch for external vault proxy payment intent"
);
}
}
Ok(())
}
#[cfg(feature = "v2")]
async fn update_payment_method<'a>(
&'a self,
state: &SessionState,
platform: &domain::Platform,
payment_data: &mut PaymentConfirmData<F>,
) {
if let (true, Some(payment_method)) = (
payment_data.payment_attempt.customer_acceptance.is_some(),
payment_data.payment_method.as_ref(),
) {
payment_methods::update_payment_method_status_internal(
state,
platform.get_processor().get_key_store(),
platform.get_processor().get_account().storage_scheme,
common_enums::PaymentMethodStatus::Active,
payment_method.get_id(),
)
.await
.map_err(|err| router_env::logger::error!(err=?err));
};
}
#[instrument(skip_all)]
async fn populate_payment_data<'a>(
&'a self,
_state: &SessionState,
payment_data: &mut PaymentConfirmData<F>,
_platform: &domain::Platform,
_business_profile: &domain::Profile,
connector_data: &api::ConnectorData,
) -> CustomResult<(), errors::ApiErrorResponse> {
let connector_request_reference_id = connector_data
.connector
.generate_connector_request_reference_id(
&payment_data.payment_intent,
&payment_data.payment_attempt,
);
payment_data.set_connector_request_reference_id(Some(connector_request_reference_id));
Ok(())
}
async fn perform_routing<'a>(
&'a self,
platform: &domain::Platform,
business_profile: &domain::Profile,
state: &SessionState,
payment_data: &mut PaymentConfirmData<F>,
) -> CustomResult<ConnectorCallType, errors::ApiErrorResponse> {
payments::connector_selection(state, platform, business_profile, payment_data, None).await
}
}
#[async_trait]
impl<F: Clone + Sync> UpdateTracker<F, PaymentConfirmData<F>, ExternalVaultProxyPaymentsRequest>
for ExternalVaultProxyPaymentIntent
{
#[instrument(skip_all)]
async fn update_trackers<'b>(
&'b self,
state: &'b SessionState,
_req_state: ReqState,
processor: &domain::Processor,
mut payment_data: PaymentConfirmData<F>,
_customer: Option<domain::Customer>,
_frm_suggestion: Option<api_models::enums::FrmSuggestion>,
_header_payload: hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<(BoxedConfirmOperation<'b, F>, PaymentConfirmData<F>)>
where
F: 'b + Send,
{
let db = &*state.store;
let storage_scheme = processor.get_account().storage_scheme;
let key_store = processor.get_key_store();
let intent_status = common_enums::IntentStatus::Processing;
let attempt_status = common_enums::AttemptStatus::Pending;
let connector = payment_data
.payment_attempt
.connector
.clone()
.get_required_value("connector")
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Connector is none when constructing response")?;
let merchant_connector_id = Some(
payment_data
.payment_attempt
.merchant_connector_id
.clone()
.get_required_value("merchant_connector_id")
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Merchant connector id is none when constructing response")?,
);
let payment_intent_update =
hyperswitch_domain_models::payments::payment_intent::PaymentIntentUpdate::ConfirmIntent {
status: intent_status,
updated_by: storage_scheme.to_string(),
active_attempt_id: Some(payment_data.payment_attempt.id.clone()),
};
let authentication_type = payment_data
.payment_intent
.authentication_type
.unwrap_or_default();
let connector_request_reference_id = payment_data
.payment_attempt
.connector_request_reference_id
.clone();
let connector_response_reference_id = payment_data
.payment_attempt
.connector_response_reference_id
.clone();
let payment_attempt_update = hyperswitch_domain_models::payments::payment_attempt::PaymentAttemptUpdate::ConfirmIntent {
status: attempt_status,
updated_by: storage_scheme.to_string(),
connector,
merchant_connector_id,
authentication_type,
connector_request_reference_id,
connector_response_reference_id,
};
let updated_payment_intent = db
.update_payment_intent(
payment_data.payment_intent.clone(),
payment_intent_update,
key_store,
storage_scheme,
)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Unable to update payment intent")?;
payment_data.payment_intent = updated_payment_intent;
let updated_payment_attempt = db
.update_payment_attempt(
key_store,
payment_data.payment_attempt.clone(),
payment_attempt_update,
storage_scheme,
)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Unable to update payment attempt")?;
payment_data.payment_attempt = updated_payment_attempt;
Ok((Box::new(self), payment_data))
}
}
#[cfg(feature = "v2")]
#[async_trait]
impl<F: Clone> PostUpdateTracker<F, PaymentConfirmData<F>, types::PaymentsAuthorizeData>
for ExternalVaultProxyPaymentIntent
{
async fn update_tracker<'b>(
&'b self,
state: &'b SessionState,
mut payment_data: PaymentConfirmData<F>,
response: types::RouterData<F, types::PaymentsAuthorizeData, types::PaymentsResponseData>,
key_store: &domain::MerchantKeyStore,
storage_scheme: enums::MerchantStorageScheme,
) -> RouterResult<PaymentConfirmData<F>>
where
F: 'b + Send + Sync,
types::RouterData<F, types::PaymentsAuthorizeData, types::PaymentsResponseData>:
hyperswitch_domain_models::router_data::TrackerPostUpdateObjects<
F,
types::PaymentsAuthorizeData,
PaymentConfirmData<F>,
>,
{
use hyperswitch_domain_models::router_data::TrackerPostUpdateObjects;
let db = &*state.store;
let response_router_data = response;
let payment_intent_update =
response_router_data.get_payment_intent_update(&payment_data, storage_scheme);
let payment_attempt_update =
response_router_data.get_payment_attempt_update(&payment_data, storage_scheme);
let updated_payment_intent = db
.update_payment_intent(
payment_data.payment_intent,
payment_intent_update,
key_store,
storage_scheme,
)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Unable to update payment intent")?;
let updated_payment_attempt = db
.update_payment_attempt(
key_store,
payment_data.payment_attempt,
payment_attempt_update,
storage_scheme,
)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Unable to update payment attempt")?;
payment_data.payment_intent = updated_payment_intent;
payment_data.payment_attempt = updated_payment_attempt;
// TODO: Add external vault specific post-update logic
Ok(payment_data)
}
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/payments/operations/proxy_payments_intent.rs | crates/router/src/core/payments/operations/proxy_payments_intent.rs | use api_models::payments::ProxyPaymentsRequest;
use async_trait::async_trait;
use common_enums::enums;
use common_utils::types::keymanager::ToEncryptable;
use error_stack::ResultExt;
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData, payments::PaymentConfirmData,
};
use hyperswitch_interfaces::api::ConnectorSpecifications;
use masking::PeekInterface;
use router_env::{instrument, tracing};
use super::{Domain, GetTracker, Operation, PostUpdateTracker, UpdateTracker, ValidateRequest};
use crate::{
core::{
errors::{self, CustomResult, RouterResult, StorageErrorExt},
payments::{
operations::{self, ValidateStatusForOperation},
OperationSessionGetters, OperationSessionSetters,
},
},
routes::{app::ReqState, SessionState},
types::{
self,
api::{self, ConnectorCallType},
domain::{self, types as domain_types},
storage::{self, enums as storage_enums},
},
utils::OptionExt,
};
#[derive(Debug, Clone, Copy)]
pub struct PaymentProxyIntent;
impl ValidateStatusForOperation for PaymentProxyIntent {
/// Validate if the current operation can be performed on the current status of the payment intent
fn validate_status_for_operation(
&self,
intent_status: common_enums::IntentStatus,
) -> Result<(), errors::ApiErrorResponse> {
match intent_status {
//Failed state is included here so that in PCR, retries can be done for failed payments, otherwise for a failed attempt it was asking for new payment_intent
common_enums::IntentStatus::RequiresPaymentMethod
| common_enums::IntentStatus::Failed
| common_enums::IntentStatus::Processing
| common_enums::IntentStatus::PartiallyCapturedAndProcessing => Ok(()),
//Failed state is included here so that in PCR, retries can be done for failed payments, otherwise for a failed attempt it was asking for new payment_intent
common_enums::IntentStatus::RequiresPaymentMethod
| common_enums::IntentStatus::Failed => Ok(()),
common_enums::IntentStatus::Conflicted
| common_enums::IntentStatus::Succeeded
| common_enums::IntentStatus::Cancelled
| common_enums::IntentStatus::CancelledPostCapture
| common_enums::IntentStatus::RequiresCustomerAction
| common_enums::IntentStatus::RequiresMerchantAction
| common_enums::IntentStatus::RequiresCapture
| common_enums::IntentStatus::PartiallyAuthorizedAndRequiresCapture
| common_enums::IntentStatus::PartiallyCaptured
| common_enums::IntentStatus::RequiresConfirmation
| common_enums::IntentStatus::PartiallyCapturedAndCapturable
| common_enums::IntentStatus::PartiallyCapturedAndProcessing
| common_enums::IntentStatus::Expired => {
Err(errors::ApiErrorResponse::PaymentUnexpectedState {
current_flow: format!("{self:?}"),
field_name: "status".to_string(),
current_value: intent_status.to_string(),
states: ["requires_payment_method".to_string()].join(", "),
})
}
}
}
}
type BoxedConfirmOperation<'b, F> =
super::BoxedOperation<'b, F, ProxyPaymentsRequest, PaymentConfirmData<F>>;
impl<F: Send + Clone + Sync> Operation<F, ProxyPaymentsRequest> for &PaymentProxyIntent {
type Data = PaymentConfirmData<F>;
fn to_validate_request(
&self,
) -> RouterResult<&(dyn ValidateRequest<F, ProxyPaymentsRequest, Self::Data> + Send + Sync)>
{
Ok(*self)
}
fn to_get_tracker(
&self,
) -> RouterResult<&(dyn GetTracker<F, Self::Data, ProxyPaymentsRequest> + Send + Sync)> {
Ok(*self)
}
fn to_domain(&self) -> RouterResult<&(dyn Domain<F, ProxyPaymentsRequest, Self::Data>)> {
Ok(*self)
}
fn to_update_tracker(
&self,
) -> RouterResult<&(dyn UpdateTracker<F, Self::Data, ProxyPaymentsRequest> + Send + Sync)> {
Ok(*self)
}
}
#[automatically_derived]
impl<F: Send + Clone + Sync> Operation<F, ProxyPaymentsRequest> for PaymentProxyIntent {
type Data = PaymentConfirmData<F>;
fn to_validate_request(
&self,
) -> RouterResult<&(dyn ValidateRequest<F, ProxyPaymentsRequest, Self::Data> + Send + Sync)>
{
Ok(self)
}
fn to_get_tracker(
&self,
) -> RouterResult<&(dyn GetTracker<F, Self::Data, ProxyPaymentsRequest> + Send + Sync)> {
Ok(self)
}
fn to_domain(&self) -> RouterResult<&dyn Domain<F, ProxyPaymentsRequest, Self::Data>> {
Ok(self)
}
fn to_update_tracker(
&self,
) -> RouterResult<&(dyn UpdateTracker<F, Self::Data, ProxyPaymentsRequest> + Send + Sync)> {
Ok(self)
}
}
impl<F: Send + Clone + Sync> ValidateRequest<F, ProxyPaymentsRequest, PaymentConfirmData<F>>
for PaymentProxyIntent
{
#[instrument(skip_all)]
fn validate_request<'a, 'b>(
&'b self,
_request: &ProxyPaymentsRequest,
platform: &'a domain::Platform,
) -> RouterResult<operations::ValidateResult> {
let validate_result = operations::ValidateResult {
merchant_id: platform.get_processor().get_account().get_id().to_owned(),
storage_scheme: platform.get_processor().get_account().storage_scheme,
requeue: false,
};
Ok(validate_result)
}
}
#[async_trait]
impl<F: Send + Clone + Sync> GetTracker<F, PaymentConfirmData<F>, ProxyPaymentsRequest>
for PaymentProxyIntent
{
#[instrument(skip_all)]
async fn get_trackers<'a>(
&'a self,
state: &'a SessionState,
payment_id: &common_utils::id_type::GlobalPaymentId,
request: &ProxyPaymentsRequest,
platform: &domain::Platform,
_profile: &domain::Profile,
header_payload: &hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<operations::GetTrackerResponse<PaymentConfirmData<F>>> {
let db = &*state.store;
let key_manager_state = &state.into();
let storage_scheme = platform.get_processor().get_account().storage_scheme;
let payment_intent = db
.find_payment_intent_by_id(
payment_id,
platform.get_processor().get_key_store(),
storage_scheme,
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
self.validate_status_for_operation(payment_intent.status)?;
let cell_id = state.conf.cell_information.id.clone();
let batch_encrypted_data = domain_types::crypto_operation(
key_manager_state,
common_utils::type_name!(hyperswitch_domain_models::payments::payment_attempt::PaymentAttempt),
domain_types::CryptoOperation::BatchEncrypt(
hyperswitch_domain_models::payments::payment_attempt::FromRequestEncryptablePaymentAttempt::to_encryptable(
hyperswitch_domain_models::payments::payment_attempt::FromRequestEncryptablePaymentAttempt {
payment_method_billing_address: None,
},
),
),
common_utils::types::keymanager::Identifier::Merchant(platform.get_processor().get_account().get_id().to_owned()),
platform.get_processor().get_key_store().key.peek(),
)
.await
.and_then(|val| val.try_into_batchoperation())
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed while encrypting payment intent details".to_string())?;
let encrypted_data =
hyperswitch_domain_models::payments::payment_attempt::FromRequestEncryptablePaymentAttempt::from_encryptable(batch_encrypted_data)
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed while encrypting payment intent details")?;
let active_attempt_id = payment_intent.active_attempt_id.clone();
let payment_attempt = match active_attempt_id {
Some(ref active_attempt_id) => db
.find_payment_attempt_by_id(
platform.get_processor().get_key_store(),
active_attempt_id,
storage_scheme,
)
.await
.change_context(errors::ApiErrorResponse::PaymentNotFound)
.attach_printable("Could not find payment attempt")?,
None => {
let payment_attempt_domain_model: hyperswitch_domain_models::payments::payment_attempt::PaymentAttempt =
hyperswitch_domain_models::payments::payment_attempt::PaymentAttempt::proxy_create_domain_model(
&payment_intent,
cell_id,
storage_scheme,
request,
encrypted_data
)
.await?;
db.insert_payment_attempt(
platform.get_processor().get_key_store(),
payment_attempt_domain_model,
storage_scheme,
)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Could not insert payment attempt")?
}
};
let processor_payment_token = request.recurring_details.processor_payment_token.clone();
let payment_address = hyperswitch_domain_models::payment_address::PaymentAddress::new(
payment_intent
.shipping_address
.clone()
.map(|address| address.into_inner()),
payment_intent
.billing_address
.clone()
.map(|address| address.into_inner()),
payment_attempt
.payment_method_billing_address
.clone()
.map(|address| address.into_inner()),
Some(true),
);
let mandate_data_input = api_models::payments::MandateIds {
mandate_id: None,
mandate_reference_id: Some(
api_models::payments::MandateReferenceId::ConnectorMandateId(
api_models::payments::ConnectorMandateReferenceId::new(
Some(processor_payment_token),
None,
None,
None,
None,
None,
),
),
),
};
let payment_data = PaymentConfirmData {
flow: std::marker::PhantomData,
payment_intent,
payment_attempt,
payment_method_data: Some(PaymentMethodData::MandatePayment),
payment_address,
mandate_data: Some(mandate_data_input),
payment_method: None,
merchant_connector_details: None,
external_vault_pmd: None,
webhook_url: None,
};
let get_trackers_response = operations::GetTrackerResponse { payment_data };
Ok(get_trackers_response)
}
}
#[async_trait]
impl<F: Clone + Send + Sync> Domain<F, ProxyPaymentsRequest, PaymentConfirmData<F>>
for PaymentProxyIntent
{
async fn get_customer_details<'a>(
&'a self,
_state: &SessionState,
_payment_data: &mut PaymentConfirmData<F>,
_merchant_key_store: &domain::MerchantKeyStore,
_storage_scheme: storage_enums::MerchantStorageScheme,
) -> CustomResult<(BoxedConfirmOperation<'a, F>, Option<domain::Customer>), errors::StorageError>
{
Ok((Box::new(self), None))
}
#[instrument(skip_all)]
async fn make_pm_data<'a>(
&'a self,
_state: &'a SessionState,
_payment_data: &mut PaymentConfirmData<F>,
_storage_scheme: storage_enums::MerchantStorageScheme,
_key_store: &domain::MerchantKeyStore,
_customer: &Option<domain::Customer>,
_business_profile: &domain::Profile,
_should_retry_with_pan: bool,
) -> RouterResult<(
BoxedConfirmOperation<'a, F>,
Option<PaymentMethodData>,
Option<String>,
)> {
Ok((Box::new(self), None, None))
}
#[instrument(skip_all)]
async fn populate_payment_data<'a>(
&'a self,
_state: &SessionState,
payment_data: &mut PaymentConfirmData<F>,
_platform: &domain::Platform,
_business_profile: &domain::Profile,
connector_data: &api::ConnectorData,
) -> CustomResult<(), errors::ApiErrorResponse> {
let connector_request_reference_id = connector_data
.connector
.generate_connector_request_reference_id(
&payment_data.payment_intent,
&payment_data.payment_attempt,
);
payment_data.set_connector_request_reference_id(Some(connector_request_reference_id));
Ok(())
}
async fn perform_routing<'a>(
&'a self,
_platform: &domain::Platform,
_business_profile: &domain::Profile,
state: &SessionState,
payment_data: &mut PaymentConfirmData<F>,
) -> CustomResult<ConnectorCallType, errors::ApiErrorResponse> {
let connector_name = payment_data.get_payment_attempt_connector();
if let Some(connector_name) = connector_name {
let merchant_connector_id = payment_data.get_merchant_connector_id_in_attempt();
let connector_data = api::ConnectorData::get_connector_by_name(
&state.conf.connectors,
connector_name,
api::GetToken::Connector,
merchant_connector_id,
)?;
Ok(ConnectorCallType::PreDetermined(connector_data.into()))
} else {
Err(error_stack::Report::new(
errors::ApiErrorResponse::InternalServerError,
))
}
}
}
#[async_trait]
impl<F: Clone + Sync> UpdateTracker<F, PaymentConfirmData<F>, ProxyPaymentsRequest>
for PaymentProxyIntent
{
#[instrument(skip_all)]
async fn update_trackers<'b>(
&'b self,
state: &'b SessionState,
_req_state: ReqState,
processor: &domain::Processor,
mut payment_data: PaymentConfirmData<F>,
_customer: Option<domain::Customer>,
_frm_suggestion: Option<api_models::enums::FrmSuggestion>,
_header_payload: hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<(BoxedConfirmOperation<'b, F>, PaymentConfirmData<F>)>
where
F: 'b + Send,
{
let db = &*state.store;
let storage_scheme = processor.get_account().storage_scheme;
let key_store = processor.get_key_store();
let intent_status = common_enums::IntentStatus::Processing;
let attempt_status = common_enums::AttemptStatus::Pending;
let connector = payment_data
.payment_attempt
.connector
.clone()
.get_required_value("connector")
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Connector is none when constructing response")?;
let merchant_connector_id = Some(
payment_data
.payment_attempt
.merchant_connector_id
.clone()
.get_required_value("merchant_connector_id")
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Merchant connector id is none when constructing response")?,
);
let active_attempt_id = payment_data.payment_intent.active_attempt_id.clone();
let payment_intent_update =
hyperswitch_domain_models::payments::payment_intent::PaymentIntentUpdate::ConfirmIntent {
status: intent_status,
updated_by: storage_scheme.to_string(),
active_attempt_id,
};
let authentication_type = payment_data
.payment_intent
.authentication_type
.unwrap_or_default();
let connector_request_reference_id = payment_data
.payment_attempt
.connector_request_reference_id
.clone();
let connector_response_reference_id = payment_data
.payment_attempt
.connector_response_reference_id
.clone();
let payment_attempt_update = hyperswitch_domain_models::payments::payment_attempt::PaymentAttemptUpdate::ConfirmIntent {
status: attempt_status,
updated_by: storage_scheme.to_string(),
connector,
merchant_connector_id,
authentication_type,
connector_request_reference_id,
connector_response_reference_id,
};
let updated_payment_intent = db
.update_payment_intent(
payment_data.payment_intent.clone(),
payment_intent_update,
key_store,
storage_scheme,
)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Unable to update payment intent")?;
payment_data.payment_intent = updated_payment_intent;
let updated_payment_attempt = db
.update_payment_attempt(
key_store,
payment_data.payment_attempt.clone(),
payment_attempt_update,
storage_scheme,
)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Unable to update payment attempt")?;
payment_data.payment_attempt = updated_payment_attempt;
Ok((Box::new(self), payment_data))
}
}
#[cfg(feature = "v2")]
#[async_trait]
impl<F: Clone> PostUpdateTracker<F, PaymentConfirmData<F>, types::PaymentsAuthorizeData>
for PaymentProxyIntent
{
async fn update_tracker<'b>(
&'b self,
state: &'b SessionState,
mut payment_data: PaymentConfirmData<F>,
response: types::RouterData<F, types::PaymentsAuthorizeData, types::PaymentsResponseData>,
key_store: &domain::MerchantKeyStore,
storage_scheme: enums::MerchantStorageScheme,
) -> RouterResult<PaymentConfirmData<F>>
where
F: 'b + Send + Sync,
types::RouterData<F, types::PaymentsAuthorizeData, types::PaymentsResponseData>:
hyperswitch_domain_models::router_data::TrackerPostUpdateObjects<
F,
types::PaymentsAuthorizeData,
PaymentConfirmData<F>,
>,
{
use hyperswitch_domain_models::router_data::TrackerPostUpdateObjects;
let db = &*state.store;
let response_router_data = response;
let payment_intent_update =
response_router_data.get_payment_intent_update(&payment_data, storage_scheme);
let payment_attempt_update =
response_router_data.get_payment_attempt_update(&payment_data, storage_scheme);
let updated_payment_intent = db
.update_payment_intent(
payment_data.payment_intent,
payment_intent_update,
key_store,
storage_scheme,
)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Unable to update payment intent")?;
let updated_payment_attempt = db
.update_payment_attempt(
key_store,
payment_data.payment_attempt,
payment_attempt_update,
storage_scheme,
)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Unable to update payment attempt")?;
payment_data.payment_intent = updated_payment_intent;
payment_data.payment_attempt = updated_payment_attempt;
Ok(payment_data)
}
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/payments/operations/payment_start.rs | crates/router/src/core/payments/operations/payment_start.rs | use std::marker::PhantomData;
use api_models::enums::FrmSuggestion;
use async_trait::async_trait;
use error_stack::ResultExt;
use router_derive::PaymentOperation;
use router_env::{instrument, tracing};
use super::{BoxedOperation, Domain, GetTracker, Operation, UpdateTracker, ValidateRequest};
use crate::{
core::{
errors::{self, CustomResult, RouterResult, StorageErrorExt},
payments::{helpers, operations, CustomerDetails, PaymentAddress, PaymentData},
},
routes::{app::ReqState, SessionState},
services,
types::{
api::{self, PaymentIdTypeExt},
domain,
storage::{self, enums as storage_enums},
},
utils::OptionExt,
};
#[derive(Debug, Clone, Copy, PaymentOperation)]
#[operation(operations = "all", flow = "start")]
pub struct PaymentStart;
type PaymentSessionOperation<'b, F> =
BoxedOperation<'b, F, api::PaymentsStartRequest, PaymentData<F>>;
#[async_trait]
impl<F: Send + Clone + Sync> GetTracker<F, PaymentData<F>, api::PaymentsStartRequest>
for PaymentStart
{
#[instrument(skip_all)]
async fn get_trackers<'a>(
&'a self,
state: &'a SessionState,
payment_id: &api::PaymentIdType,
_request: &api::PaymentsStartRequest,
platform: &domain::Platform,
_auth_flow: services::AuthFlow,
_header_payload: &hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<
operations::GetTrackerResponse<'a, F, api::PaymentsStartRequest, PaymentData<F>>,
> {
let (mut payment_intent, payment_attempt, currency, amount);
let db = &*state.store;
let merchant_id = platform.get_processor().get_account().get_id();
let storage_scheme = platform.get_processor().get_account().storage_scheme;
let payment_id = payment_id
.get_payment_intent_id()
.change_context(errors::ApiErrorResponse::PaymentNotFound)?;
payment_intent = db
.find_payment_intent_by_payment_id_merchant_id(
&payment_id,
merchant_id,
platform.get_processor().get_key_store(),
storage_scheme,
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
// TODO (#7195): Add platform merchant account validation once Merchant ID auth is solved
helpers::validate_payment_status_against_not_allowed_statuses(
payment_intent.status,
&[
storage_enums::IntentStatus::Failed,
storage_enums::IntentStatus::Succeeded,
],
"update",
)?;
helpers::authenticate_client_secret(
payment_intent.client_secret.as_ref(),
&payment_intent,
)?;
payment_attempt = db
.find_payment_attempt_by_payment_id_merchant_id_attempt_id(
&payment_intent.payment_id,
merchant_id,
payment_intent.active_attempt.get_id().as_str(),
storage_scheme,
platform.get_processor().get_key_store(),
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
currency = payment_attempt.currency.get_required_value("currency")?;
amount = payment_attempt.get_total_amount().into();
let shipping_address = helpers::get_address_by_id(
state,
payment_intent.shipping_address_id.clone(),
platform.get_processor().get_key_store(),
&payment_intent.payment_id,
merchant_id,
platform.get_processor().get_account().storage_scheme,
)
.await?;
let billing_address = helpers::get_address_by_id(
state,
payment_intent.billing_address_id.clone(),
platform.get_processor().get_key_store(),
&payment_intent.payment_id,
merchant_id,
platform.get_processor().get_account().storage_scheme,
)
.await?;
let payment_method_billing = helpers::get_address_by_id(
state,
payment_attempt.payment_method_billing_address_id.clone(),
platform.get_processor().get_key_store(),
&payment_intent.payment_id,
merchant_id,
platform.get_processor().get_account().storage_scheme,
)
.await?;
let token_data = if let Some(token) = payment_attempt.payment_token.clone() {
Some(
helpers::retrieve_payment_token_data(state, token, payment_attempt.payment_method)
.await?,
)
} else {
None
};
payment_intent.shipping_address_id = shipping_address.clone().map(|i| i.address_id);
payment_intent.billing_address_id = billing_address.clone().map(|i| i.address_id);
let customer_details = CustomerDetails {
customer_id: payment_intent.customer_id.clone(),
..CustomerDetails::default()
};
let profile_id = payment_intent
.profile_id
.as_ref()
.get_required_value("profile_id")
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("'profile_id' not set in payment intent")?;
let business_profile = db
.find_business_profile_by_profile_id(
platform.get_processor().get_key_store(),
profile_id,
)
.await
.to_not_found_response(errors::ApiErrorResponse::ProfileNotFound {
id: profile_id.get_string_repr().to_owned(),
})?;
let payment_data = PaymentData {
flow: PhantomData,
payment_intent,
currency,
amount,
email: None,
mandate_id: None,
mandate_connector: None,
setup_mandate: None,
customer_acceptance: None,
token: payment_attempt.payment_token.clone(),
address: PaymentAddress::new(
shipping_address.as_ref().map(From::from),
billing_address.as_ref().map(From::from),
payment_method_billing.as_ref().map(From::from),
business_profile.use_billing_as_payment_method_billing,
),
token_data,
confirm: Some(payment_attempt.confirm),
payment_attempt,
payment_method_data: None,
payment_method_token: None,
payment_method_info: None,
force_sync: None,
all_keys_required: None,
refunds: vec![],
disputes: vec![],
attempts: None,
sessions_token: vec![],
card_cvc: None,
creds_identifier: None,
pm_token: None,
connector_customer_id: None,
recurring_mandate_payment_data: None,
multiple_capture_data: None,
redirect_response: None,
surcharge_details: None,
frm_message: None,
payment_link_data: None,
incremental_authorization_details: None,
authorizations: vec![],
authentication: None,
recurring_details: None,
poll_config: None,
tax_data: None,
session_id: None,
service_details: None,
card_testing_guard_data: None,
vault_operation: None,
threeds_method_comp_ind: None,
whole_connector_response: None,
is_manual_retry_enabled: None,
is_l2_l3_enabled: false,
external_authentication_data: None,
};
let get_trackers_response = operations::GetTrackerResponse {
operation: Box::new(self),
customer_details: Some(customer_details),
payment_data,
business_profile,
mandate_type: None,
};
Ok(get_trackers_response)
}
}
#[async_trait]
impl<F: Clone + Sync> UpdateTracker<F, PaymentData<F>, api::PaymentsStartRequest> for PaymentStart {
#[instrument(skip_all)]
async fn update_trackers<'b>(
&'b self,
_state: &'b SessionState,
_req_state: ReqState,
_processor: &domain::Processor,
payment_data: PaymentData<F>,
_customer: Option<domain::Customer>,
_frm_suggestion: Option<FrmSuggestion>,
_header_payload: hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<(PaymentSessionOperation<'b, F>, PaymentData<F>)>
where
F: 'b + Send,
{
Ok((Box::new(self), payment_data))
}
}
impl<F: Send + Clone + Sync> ValidateRequest<F, api::PaymentsStartRequest, PaymentData<F>>
for PaymentStart
{
#[instrument(skip_all)]
fn validate_request<'a, 'b>(
&'b self,
request: &api::PaymentsStartRequest,
processor: &'a domain::Processor,
) -> RouterResult<(PaymentSessionOperation<'b, F>, operations::ValidateResult)> {
let request_merchant_id = Some(&request.merchant_id);
helpers::validate_merchant_id(processor.get_account().get_id(), request_merchant_id)
.change_context(errors::ApiErrorResponse::InvalidDataFormat {
field_name: "merchant_id".to_string(),
expected_format: "merchant_id from merchant account".to_string(),
})?;
let payment_id = request.payment_id.clone();
Ok((
Box::new(self),
operations::ValidateResult {
merchant_id: processor.get_account().get_id().to_owned(),
payment_id: api::PaymentIdType::PaymentIntentId(payment_id),
storage_scheme: processor.get_account().storage_scheme,
requeue: false,
},
))
}
}
#[async_trait]
impl<
F: Clone + Send,
Op: Send + Sync + Operation<F, api::PaymentsStartRequest, Data = PaymentData<F>>,
> Domain<F, api::PaymentsStartRequest, PaymentData<F>> for Op
where
for<'a> &'a Op: Operation<F, api::PaymentsStartRequest, Data = PaymentData<F>>,
{
#[instrument(skip_all)]
async fn populate_raw_customer_details<'a>(
&'a self,
state: &SessionState,
payment_data: &mut PaymentData<F>,
request: Option<&CustomerDetails>,
processor: &domain::Processor,
) -> CustomResult<(), errors::StorageError> {
helpers::populate_raw_customer_details(state, payment_data, request, processor).await
}
#[instrument(skip_all)]
async fn get_or_create_customer_details<'a>(
&'a self,
state: &SessionState,
payment_data: &mut PaymentData<F>,
request: Option<CustomerDetails>,
provider: &domain::Provider,
) -> CustomResult<
(PaymentSessionOperation<'a, F>, Option<domain::Customer>),
errors::StorageError,
> {
match provider.get_account().merchant_account_type {
common_enums::MerchantAccountType::Standard => {
helpers::create_customer_if_not_exist(
state,
Box::new(self),
payment_data,
request,
provider,
)
.await
}
common_enums::MerchantAccountType::Platform => {
let customer = helpers::get_customer_if_exists(
state,
request.as_ref().and_then(|r| r.customer_id.as_ref()),
payment_data.payment_intent.customer_id.as_ref(),
provider,
)
.await?
.inspect(|cust| {
payment_data.email = payment_data
.email
.clone()
.or_else(|| cust.email.clone().map(Into::into));
});
Ok((Box::new(self), customer))
}
common_enums::MerchantAccountType::Connected => {
Err(errors::StorageError::ValueNotFound(
"Connected merchant cannot be a provider".to_string(),
)
.into())
}
}
}
#[instrument(skip_all)]
async fn make_pm_data<'a>(
&'a self,
state: &'a SessionState,
payment_data: &mut PaymentData<F>,
storage_scheme: storage_enums::MerchantStorageScheme,
merchant_key_store: &domain::MerchantKeyStore,
customer: &Option<domain::Customer>,
business_profile: &domain::Profile,
should_retry_with_pan: bool,
) -> RouterResult<(
PaymentSessionOperation<'a, F>,
Option<domain::PaymentMethodData>,
Option<String>,
)> {
if payment_data
.payment_attempt
.connector
.clone()
.map(|connector_name| connector_name == *"bluesnap".to_string())
.unwrap_or(false)
{
Box::pin(helpers::make_pm_data(
Box::new(self),
state,
payment_data,
merchant_key_store,
customer,
storage_scheme,
business_profile,
should_retry_with_pan,
))
.await
} else {
Ok((Box::new(self), None, None))
}
}
async fn get_connector<'a>(
&'a self,
_platform: &domain::Platform,
state: &SessionState,
_request: &api::PaymentsStartRequest,
_payment_intent: &storage::PaymentIntent,
) -> CustomResult<api::ConnectorChoice, errors::ApiErrorResponse> {
helpers::get_connector_default(state, None).await
}
#[instrument(skip_all)]
async fn guard_payment_against_blocklist<'a>(
&'a self,
_state: &SessionState,
_platform: &domain::Platform,
_payment_data: &mut PaymentData<F>,
) -> CustomResult<bool, errors::ApiErrorResponse> {
Ok(false)
}
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/payments/operations/payment_approve.rs | crates/router/src/core/payments/operations/payment_approve.rs | use std::marker::PhantomData;
use api_models::enums::{AttemptStatus, FrmSuggestion, IntentStatus};
use async_trait::async_trait;
use error_stack::ResultExt;
use router_derive::PaymentOperation;
use router_env::{instrument, tracing};
use super::{BoxedOperation, Domain, GetTracker, Operation, UpdateTracker, ValidateRequest};
use crate::{
core::{
errors::{self, RouterResult, StorageErrorExt},
payments::{helpers, operations, PaymentData},
},
events::audit_events::{AuditEvent, AuditEventType},
routes::{app::ReqState, SessionState},
services,
types::{
api::{self, PaymentIdTypeExt},
domain, storage, PaymentAddress,
},
utils::OptionExt,
};
#[derive(Debug, Clone, Copy, PaymentOperation)]
#[operation(operations = "all", flow = "capture")]
pub struct PaymentApprove;
type PaymentApproveOperation<'a, F> =
BoxedOperation<'a, F, api::PaymentsCaptureRequest, PaymentData<F>>;
#[async_trait]
impl<F: Send + Clone + Sync> GetTracker<F, PaymentData<F>, api::PaymentsCaptureRequest>
for PaymentApprove
{
#[instrument(skip_all)]
async fn get_trackers<'a>(
&'a self,
state: &'a SessionState,
payment_id: &api::PaymentIdType,
_request: &api::PaymentsCaptureRequest,
platform: &domain::Platform,
_auth_flow: services::AuthFlow,
_header_payload: &hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<
operations::GetTrackerResponse<'a, F, api::PaymentsCaptureRequest, PaymentData<F>>,
> {
let db = &*state.store;
let merchant_id = platform.get_processor().get_account().get_id();
let storage_scheme = platform.get_processor().get_account().storage_scheme;
let (mut payment_intent, payment_attempt, currency, amount);
let payment_id = payment_id
.get_payment_intent_id()
.change_context(errors::ApiErrorResponse::PaymentNotFound)?;
payment_intent = db
.find_payment_intent_by_payment_id_merchant_id(
&payment_id,
merchant_id,
platform.get_processor().get_key_store(),
storage_scheme,
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
helpers::validate_payment_status_against_not_allowed_statuses(
payment_intent.status,
&[IntentStatus::Failed, IntentStatus::Succeeded],
"approve",
)?;
let profile_id = payment_intent
.profile_id
.as_ref()
.get_required_value("profile_id")
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("'profile_id' not set in payment intent")?;
let business_profile = state
.store
.find_business_profile_by_profile_id(
platform.get_processor().get_key_store(),
profile_id,
)
.await
.to_not_found_response(errors::ApiErrorResponse::ProfileNotFound {
id: profile_id.get_string_repr().to_owned(),
})?;
let attempt_id = payment_intent.active_attempt.get_id().clone();
payment_attempt = db
.find_payment_attempt_by_payment_id_merchant_id_attempt_id(
&payment_intent.payment_id,
merchant_id,
&attempt_id.clone(),
storage_scheme,
platform.get_processor().get_key_store(),
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
currency = payment_attempt.currency.get_required_value("currency")?;
amount = payment_attempt.get_total_amount().into();
let shipping_address = helpers::get_address_by_id(
state,
payment_intent.shipping_address_id.clone(),
platform.get_processor().get_key_store(),
&payment_intent.payment_id,
merchant_id,
platform.get_processor().get_account().storage_scheme,
)
.await?;
let billing_address = helpers::get_address_by_id(
state,
payment_intent.billing_address_id.clone(),
platform.get_processor().get_key_store(),
&payment_intent.payment_id,
merchant_id,
platform.get_processor().get_account().storage_scheme,
)
.await?;
let payment_method_billing = helpers::get_address_by_id(
state,
payment_attempt.payment_method_billing_address_id.clone(),
platform.get_processor().get_key_store(),
&payment_intent.payment_id,
merchant_id,
platform.get_processor().get_account().storage_scheme,
)
.await?;
payment_intent.shipping_address_id = shipping_address.clone().map(|i| i.address_id);
payment_intent.billing_address_id = billing_address.clone().map(|i| i.address_id);
let frm_response = if cfg!(feature = "frm") {
db.find_fraud_check_by_payment_id(payment_intent.payment_id.clone(), platform.get_processor().get_account().get_id().clone())
.await
.change_context(errors::ApiErrorResponse::PaymentNotFound)
.attach_printable_lazy(|| {
format!("Error while retrieving frm_response, merchant_id: {}, payment_id: {attempt_id}", platform.get_processor().get_account().get_id().get_string_repr())
})
.ok()
} else {
None
};
let payment_data = PaymentData {
flow: PhantomData,
payment_intent,
payment_attempt,
currency,
amount,
email: None,
mandate_id: None,
mandate_connector: None,
setup_mandate: None,
customer_acceptance: None,
token: None,
token_data: None,
address: PaymentAddress::new(
shipping_address.as_ref().map(From::from),
billing_address.as_ref().map(From::from),
payment_method_billing.as_ref().map(From::from),
business_profile.use_billing_as_payment_method_billing,
),
confirm: None,
payment_method_data: None,
payment_method_token: None,
payment_method_info: None,
force_sync: None,
all_keys_required: None,
refunds: vec![],
disputes: vec![],
attempts: None,
sessions_token: vec![],
card_cvc: None,
creds_identifier: None,
pm_token: None,
connector_customer_id: None,
recurring_mandate_payment_data: None,
multiple_capture_data: None,
redirect_response: None,
surcharge_details: None,
frm_message: frm_response,
payment_link_data: None,
incremental_authorization_details: None,
authorizations: vec![],
authentication: None,
recurring_details: None,
poll_config: None,
tax_data: None,
session_id: None,
service_details: None,
card_testing_guard_data: None,
vault_operation: None,
threeds_method_comp_ind: None,
whole_connector_response: None,
is_manual_retry_enabled: None,
is_l2_l3_enabled: false,
external_authentication_data: None,
};
let get_trackers_response = operations::GetTrackerResponse {
operation: Box::new(self),
customer_details: None,
payment_data,
business_profile,
mandate_type: None,
};
Ok(get_trackers_response)
}
}
#[async_trait]
impl<F: Clone + Sync> UpdateTracker<F, PaymentData<F>, api::PaymentsCaptureRequest>
for PaymentApprove
{
#[instrument(skip_all)]
async fn update_trackers<'b>(
&'b self,
state: &'b SessionState,
req_state: ReqState,
processor: &domain::Processor,
mut payment_data: PaymentData<F>,
_customer: Option<domain::Customer>,
frm_suggestion: Option<FrmSuggestion>,
_header_payload: hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<(PaymentApproveOperation<'b, F>, PaymentData<F>)>
where
F: 'b + Send,
{
let storage_scheme = processor.get_account().storage_scheme;
let key_store = processor.get_key_store();
if matches!(frm_suggestion, Some(FrmSuggestion::FrmAuthorizeTransaction)) {
payment_data.payment_intent.status = IntentStatus::RequiresCapture; // In Approve flow, payment which has payment_capture_method "manual" and attempt status as "Unresolved",
payment_data.payment_attempt.status = AttemptStatus::Authorized; // We shouldn't call the connector instead we need to update the payment attempt and payment intent.
}
let intent_status_update = storage::PaymentIntentUpdate::ApproveUpdate {
status: payment_data.payment_intent.status,
merchant_decision: Some(api_models::enums::MerchantDecision::Approved.to_string()),
updated_by: storage_scheme.to_string(),
};
payment_data.payment_intent = state
.store
.update_payment_intent(
payment_data.payment_intent,
intent_status_update,
key_store,
storage_scheme,
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
state
.store
.update_payment_attempt_with_attempt_id(
payment_data.payment_attempt.clone(),
storage::PaymentAttemptUpdate::StatusUpdate {
status: payment_data.payment_attempt.status,
updated_by: storage_scheme.to_string(),
},
storage_scheme,
key_store,
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
req_state
.event_context
.event(AuditEvent::new(AuditEventType::PaymentApprove))
.with(payment_data.to_event())
.emit();
Ok((Box::new(self), payment_data))
}
}
impl<F: Send + Clone + Sync> ValidateRequest<F, api::PaymentsCaptureRequest, PaymentData<F>>
for PaymentApprove
{
#[instrument(skip_all)]
fn validate_request<'a, 'b>(
&'b self,
request: &api::PaymentsCaptureRequest,
processor: &'a domain::Processor,
) -> RouterResult<(PaymentApproveOperation<'b, F>, operations::ValidateResult)> {
let request_merchant_id = request.merchant_id.as_ref();
helpers::validate_merchant_id(processor.get_account().get_id(), request_merchant_id)
.change_context(errors::ApiErrorResponse::InvalidDataFormat {
field_name: "merchant_id".to_string(),
expected_format: "merchant_id from merchant account".to_string(),
})?;
Ok((
Box::new(self),
operations::ValidateResult {
merchant_id: processor.get_account().get_id().to_owned(),
payment_id: api::PaymentIdType::PaymentIntentId(request.payment_id.clone()),
storage_scheme: processor.get_account().storage_scheme,
requeue: false,
},
))
}
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/payments/operations/payment_cancel_v2.rs | crates/router/src/core/payments/operations/payment_cancel_v2.rs | use std::marker::PhantomData;
use api_models::enums::FrmSuggestion;
use async_trait::async_trait;
use common_utils::{ext_traits::AsyncExt, id_type::GlobalPaymentId};
use error_stack::ResultExt;
use router_env::{instrument, tracing};
use super::{
BoxedOperation, Domain, GetTracker, Operation, OperationSessionSetters, UpdateTracker,
ValidateRequest, ValidateStatusForOperation,
};
use crate::{
core::{
errors::{self, CustomResult, RouterResult, StorageErrorExt},
payments::operations,
},
routes::{app::ReqState, SessionState},
types::{
self,
api::{self, ConnectorCallType, PaymentIdTypeExt},
domain,
storage::{self, enums},
PaymentsCancelData,
},
utils::OptionExt,
};
#[derive(Debug, Clone, Copy)]
pub struct PaymentsCancel;
type BoxedCancelOperation<'b, F> = BoxedOperation<
'b,
F,
api::PaymentsCancelRequest,
hyperswitch_domain_models::payments::PaymentCancelData<F>,
>;
// Manual Operation trait implementation for V2
impl<F: Send + Clone + Sync> Operation<F, api::PaymentsCancelRequest> for &PaymentsCancel {
type Data = hyperswitch_domain_models::payments::PaymentCancelData<F>;
fn to_validate_request(
&self,
) -> RouterResult<&(dyn ValidateRequest<F, api::PaymentsCancelRequest, Self::Data> + Send + Sync)>
{
Ok(*self)
}
fn to_get_tracker(
&self,
) -> RouterResult<&(dyn GetTracker<F, Self::Data, api::PaymentsCancelRequest> + Send + Sync)>
{
Ok(*self)
}
fn to_domain(&self) -> RouterResult<&(dyn Domain<F, api::PaymentsCancelRequest, Self::Data>)> {
Ok(*self)
}
fn to_update_tracker(
&self,
) -> RouterResult<&(dyn UpdateTracker<F, Self::Data, api::PaymentsCancelRequest> + Send + Sync)>
{
Ok(*self)
}
}
#[automatically_derived]
impl<F: Send + Clone + Sync> Operation<F, api::PaymentsCancelRequest> for PaymentsCancel {
type Data = hyperswitch_domain_models::payments::PaymentCancelData<F>;
fn to_validate_request(
&self,
) -> RouterResult<&(dyn ValidateRequest<F, api::PaymentsCancelRequest, Self::Data> + Send + Sync)>
{
Ok(self)
}
fn to_get_tracker(
&self,
) -> RouterResult<&(dyn GetTracker<F, Self::Data, api::PaymentsCancelRequest> + Send + Sync)>
{
Ok(self)
}
fn to_domain(&self) -> RouterResult<&dyn Domain<F, api::PaymentsCancelRequest, Self::Data>> {
Ok(self)
}
fn to_update_tracker(
&self,
) -> RouterResult<&(dyn UpdateTracker<F, Self::Data, api::PaymentsCancelRequest> + Send + Sync)>
{
Ok(self)
}
}
#[cfg(feature = "v2")]
impl<F: Send + Clone + Sync>
ValidateRequest<
F,
api::PaymentsCancelRequest,
hyperswitch_domain_models::payments::PaymentCancelData<F>,
> for PaymentsCancel
{
#[instrument(skip_all)]
fn validate_request(
&self,
_request: &api::PaymentsCancelRequest,
platform: &domain::Platform,
) -> RouterResult<operations::ValidateResult> {
Ok(operations::ValidateResult {
merchant_id: platform.get_processor().get_account().get_id().to_owned(),
storage_scheme: platform.get_processor().get_account().storage_scheme,
requeue: false,
})
}
}
#[cfg(feature = "v2")]
#[async_trait]
impl<F: Send + Clone + Sync>
GetTracker<
F,
hyperswitch_domain_models::payments::PaymentCancelData<F>,
api::PaymentsCancelRequest,
> for PaymentsCancel
{
#[instrument(skip_all)]
async fn get_trackers<'a>(
&'a self,
state: &'a SessionState,
payment_id: &common_utils::id_type::GlobalPaymentId,
request: &api::PaymentsCancelRequest,
platform: &domain::Platform,
profile: &domain::Profile,
_header_payload: &hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<
operations::GetTrackerResponse<hyperswitch_domain_models::payments::PaymentCancelData<F>>,
> {
let db = &*state.store;
let merchant_id = platform.get_processor().get_account().get_id();
let storage_scheme = platform.get_processor().get_account().storage_scheme;
let payment_intent = db
.find_payment_intent_by_id(
payment_id,
platform.get_processor().get_key_store(),
storage_scheme,
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)
.attach_printable("Failed to find payment intent for cancellation")?;
self.validate_status_for_operation(payment_intent.status)?;
let active_attempt_id = payment_intent.active_attempt_id.as_ref().ok_or_else(|| {
errors::ApiErrorResponse::InvalidRequestData {
message: "Payment cancellation not possible - no active payment attempt found"
.to_string(),
}
})?;
let payment_attempt = db
.find_payment_attempt_by_id(
platform.get_processor().get_key_store(),
active_attempt_id,
storage_scheme,
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)
.attach_printable("Failed to find payment attempt for cancellation")?;
let mut payment_data = hyperswitch_domain_models::payments::PaymentCancelData {
flow: PhantomData,
payment_intent,
payment_attempt,
};
payment_data.set_cancellation_reason(request.cancellation_reason.clone());
let get_trackers_response = operations::GetTrackerResponse { payment_data };
Ok(get_trackers_response)
}
}
#[cfg(feature = "v2")]
#[async_trait]
impl<F: Clone + Send + Sync>
UpdateTracker<
F,
hyperswitch_domain_models::payments::PaymentCancelData<F>,
api::PaymentsCancelRequest,
> for PaymentsCancel
{
#[instrument(skip_all)]
async fn update_trackers<'b>(
&'b self,
state: &'b SessionState,
req_state: ReqState,
processor: &domain::Processor,
mut payment_data: hyperswitch_domain_models::payments::PaymentCancelData<F>,
_customer: Option<domain::Customer>,
_frm_suggestion: Option<FrmSuggestion>,
_header_payload: hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<(
BoxedCancelOperation<'b, F>,
hyperswitch_domain_models::payments::PaymentCancelData<F>,
)>
where
F: 'b + Send,
{
let db = &*state.store;
let storage_scheme = processor.get_account().storage_scheme;
let merchant_key_store = processor.get_key_store();
let payment_attempt_update = hyperswitch_domain_models::payments::payment_attempt::PaymentAttemptUpdate::VoidUpdate {
status: enums::AttemptStatus::VoidInitiated,
cancellation_reason: payment_data.payment_attempt.cancellation_reason.clone(),
updated_by: storage_scheme.to_string(),
};
let updated_payment_attempt = db
.update_payment_attempt(
merchant_key_store,
payment_data.payment_attempt.clone(),
payment_attempt_update,
storage_scheme,
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)
.attach_printable("Failed to update payment attempt for cancellation")?;
payment_data.set_payment_attempt(updated_payment_attempt);
Ok((Box::new(self), payment_data))
}
}
#[cfg(feature = "v2")]
#[async_trait]
impl<F: Send + Clone + Sync>
Domain<F, api::PaymentsCancelRequest, hyperswitch_domain_models::payments::PaymentCancelData<F>>
for PaymentsCancel
{
async fn get_customer_details<'a>(
&'a self,
_state: &SessionState,
_payment_data: &mut hyperswitch_domain_models::payments::PaymentCancelData<F>,
_merchant_key_store: &domain::MerchantKeyStore,
_storage_scheme: enums::MerchantStorageScheme,
) -> CustomResult<(BoxedCancelOperation<'a, F>, Option<domain::Customer>), errors::StorageError>
{
Ok((Box::new(*self), None))
}
async fn make_pm_data<'a>(
&'a self,
_state: &'a SessionState,
_payment_data: &mut hyperswitch_domain_models::payments::PaymentCancelData<F>,
_storage_scheme: enums::MerchantStorageScheme,
_merchant_key_store: &domain::MerchantKeyStore,
_customer: &Option<domain::Customer>,
_business_profile: &domain::Profile,
_should_retry_with_pan: bool,
) -> RouterResult<(
BoxedCancelOperation<'a, F>,
Option<domain::PaymentMethodData>,
Option<String>,
)> {
Ok((Box::new(*self), None, None))
}
async fn perform_routing<'a>(
&'a self,
_platform: &domain::Platform,
_business_profile: &domain::Profile,
state: &SessionState,
payment_data: &mut hyperswitch_domain_models::payments::PaymentCancelData<F>,
) -> RouterResult<api::ConnectorCallType> {
let payment_attempt = &payment_data.payment_attempt;
let connector = payment_attempt
.connector
.as_ref()
.get_required_value("connector")
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Connector not found for payment cancellation")?;
let merchant_connector_id = payment_attempt
.merchant_connector_id
.as_ref()
.get_required_value("merchant_connector_id")
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Merchant connector ID not found for payment cancellation")?;
let connector_data = api::ConnectorData::get_connector_by_name(
&state.conf.connectors,
connector,
api::GetToken::Connector,
Some(merchant_connector_id.to_owned()),
)
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Invalid connector name received")?;
Ok(api::ConnectorCallType::PreDetermined(connector_data.into()))
}
}
impl ValidateStatusForOperation for PaymentsCancel {
fn validate_status_for_operation(
&self,
intent_status: common_enums::IntentStatus,
) -> Result<(), errors::ApiErrorResponse> {
match intent_status {
common_enums::IntentStatus::PartiallyAuthorizedAndRequiresCapture
| common_enums::IntentStatus::PartiallyCapturedAndCapturable
| common_enums::IntentStatus::RequiresCapture => Ok(()),
common_enums::IntentStatus::Succeeded
| common_enums::IntentStatus::Failed
| common_enums::IntentStatus::Cancelled
| common_enums::IntentStatus::CancelledPostCapture
| common_enums::IntentStatus::Processing
| common_enums::IntentStatus::PartiallyCapturedAndProcessing
| common_enums::IntentStatus::RequiresCustomerAction
| common_enums::IntentStatus::RequiresMerchantAction
| common_enums::IntentStatus::RequiresPaymentMethod
| common_enums::IntentStatus::RequiresConfirmation
| common_enums::IntentStatus::PartiallyCaptured
| common_enums::IntentStatus::Conflicted
| common_enums::IntentStatus::Expired => {
Err(errors::ApiErrorResponse::PaymentUnexpectedState {
current_flow: format!("{self:?}"),
field_name: "status".to_string(),
current_value: intent_status.to_string(),
states: [
common_enums::IntentStatus::RequiresCapture,
common_enums::IntentStatus::PartiallyCapturedAndCapturable,
common_enums::IntentStatus::PartiallyAuthorizedAndRequiresCapture,
]
.map(|enum_value| enum_value.to_string())
.join(", "),
})
}
}
}
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/payments/operations/payment_status.rs | crates/router/src/core/payments/operations/payment_status.rs | use std::marker::PhantomData;
use api_models::enums::FrmSuggestion;
use async_trait::async_trait;
use common_utils::ext_traits::AsyncExt;
use error_stack::ResultExt;
use router_derive::PaymentOperation;
use router_env::{instrument, logger, tracing};
use super::{BoxedOperation, Domain, GetTracker, Operation, UpdateTracker, ValidateRequest};
use crate::{
core::{
errors::{self, CustomResult, RouterResult, StorageErrorExt},
payments::{
helpers, operations, types as payment_types, CustomerDetails, PaymentAddress,
PaymentData,
},
},
events::audit_events::{AuditEvent, AuditEventType},
routes::{app::ReqState, SessionState},
services,
types::{
api, domain,
storage::{self, enums},
},
utils::OptionExt,
};
#[derive(Debug, Clone, Copy, PaymentOperation)]
#[operation(operations = "all", flow = "sync")]
pub struct PaymentStatus;
type PaymentStatusOperation<'b, F, R> = BoxedOperation<'b, F, R, PaymentData<F>>;
impl<F: Send + Clone + Sync> Operation<F, api::PaymentsRequest> for PaymentStatus {
type Data = PaymentData<F>;
fn to_domain(&self) -> RouterResult<&dyn Domain<F, api::PaymentsRequest, PaymentData<F>>> {
Ok(self)
}
fn to_update_tracker(
&self,
) -> RouterResult<&(dyn UpdateTracker<F, PaymentData<F>, api::PaymentsRequest> + Send + Sync)>
{
Ok(self)
}
}
impl<F: Send + Clone + Sync> Operation<F, api::PaymentsRequest> for &PaymentStatus {
type Data = PaymentData<F>;
fn to_domain(&self) -> RouterResult<&dyn Domain<F, api::PaymentsRequest, PaymentData<F>>> {
Ok(*self)
}
fn to_update_tracker(
&self,
) -> RouterResult<&(dyn UpdateTracker<F, PaymentData<F>, api::PaymentsRequest> + Send + Sync)>
{
Ok(*self)
}
}
#[async_trait]
impl<F: Clone + Send + Sync> Domain<F, api::PaymentsRequest, PaymentData<F>> for PaymentStatus {
#[instrument(skip_all)]
async fn populate_raw_customer_details<'a>(
&'a self,
state: &SessionState,
payment_data: &mut PaymentData<F>,
request: Option<&CustomerDetails>,
processor: &domain::Processor,
) -> CustomResult<(), errors::StorageError> {
helpers::populate_raw_customer_details(state, payment_data, request, processor).await
}
#[instrument(skip_all)]
async fn get_or_create_customer_details<'a>(
&'a self,
state: &SessionState,
payment_data: &mut PaymentData<F>,
request: Option<CustomerDetails>,
provider: &domain::Provider,
) -> CustomResult<
(
PaymentStatusOperation<'a, F, api::PaymentsRequest>,
Option<domain::Customer>,
),
errors::StorageError,
> {
match provider.get_account().merchant_account_type {
common_enums::MerchantAccountType::Standard => {
helpers::create_customer_if_not_exist(
state,
Box::new(self),
payment_data,
request,
provider,
)
.await
}
common_enums::MerchantAccountType::Platform => {
let customer = helpers::get_customer_if_exists(
state,
request.as_ref().and_then(|r| r.customer_id.as_ref()),
payment_data.payment_intent.customer_id.as_ref(),
provider,
)
.await?
.inspect(|cust| {
payment_data.email = payment_data
.email
.clone()
.or_else(|| cust.email.clone().map(Into::into));
});
Ok((Box::new(self), customer))
}
common_enums::MerchantAccountType::Connected => {
Err(errors::StorageError::ValueNotFound(
"Connected merchant cannot be a provider".to_string(),
)
.into())
}
}
}
#[instrument(skip_all)]
async fn make_pm_data<'a>(
&'a self,
_state: &'a SessionState,
_payment_data: &mut PaymentData<F>,
_storage_scheme: enums::MerchantStorageScheme,
_merchant_key_store: &domain::MerchantKeyStore,
_customer: &Option<domain::Customer>,
_business_profile: &domain::Profile,
_should_retry_with_pan: bool,
) -> RouterResult<(
PaymentStatusOperation<'a, F, api::PaymentsRequest>,
Option<domain::PaymentMethodData>,
Option<String>,
)> {
Ok((Box::new(self), None, None))
}
#[instrument(skip_all)]
async fn add_task_to_process_tracker<'a>(
&'a self,
state: &'a SessionState,
payment_attempt: &storage::PaymentAttempt,
requeue: bool,
schedule_time: Option<time::PrimitiveDateTime>,
) -> CustomResult<(), errors::ApiErrorResponse> {
helpers::add_domain_task_to_pt(self, state, payment_attempt, requeue, schedule_time).await
}
async fn get_connector<'a>(
&'a self,
_platform: &domain::Platform,
state: &SessionState,
request: &api::PaymentsRequest,
_payment_intent: &storage::PaymentIntent,
) -> CustomResult<api::ConnectorChoice, errors::ApiErrorResponse> {
helpers::get_connector_default(state, request.routing.clone()).await
}
#[instrument(skip_all)]
async fn guard_payment_against_blocklist<'a>(
&'a self,
_state: &SessionState,
_platform: &domain::Platform,
_payment_data: &mut PaymentData<F>,
) -> CustomResult<bool, errors::ApiErrorResponse> {
Ok(false)
}
}
#[async_trait]
impl<F: Clone + Sync> UpdateTracker<F, PaymentData<F>, api::PaymentsRequest> for PaymentStatus {
async fn update_trackers<'b>(
&'b self,
_state: &'b SessionState,
req_state: ReqState,
_processor: &domain::Processor,
payment_data: PaymentData<F>,
_customer: Option<domain::Customer>,
_frm_suggestion: Option<FrmSuggestion>,
_header_payload: hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<(
PaymentStatusOperation<'b, F, api::PaymentsRequest>,
PaymentData<F>,
)>
where
F: 'b + Send,
{
req_state
.event_context
.event(AuditEvent::new(AuditEventType::PaymentStatus))
.with(payment_data.to_event())
.emit();
Ok((Box::new(self), payment_data))
}
}
#[async_trait]
impl<F: Clone + Sync> UpdateTracker<F, PaymentData<F>, api::PaymentsRetrieveRequest>
for PaymentStatus
{
async fn update_trackers<'b>(
&'b self,
_state: &'b SessionState,
req_state: ReqState,
_processor: &domain::Processor,
payment_data: PaymentData<F>,
_customer: Option<domain::Customer>,
_frm_suggestion: Option<FrmSuggestion>,
_header_payload: hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<(
PaymentStatusOperation<'b, F, api::PaymentsRetrieveRequest>,
PaymentData<F>,
)>
where
F: 'b + Send,
{
req_state
.event_context
.event(AuditEvent::new(AuditEventType::PaymentStatus))
.with(payment_data.to_event())
.emit();
Ok((Box::new(self), payment_data))
}
}
#[async_trait]
impl<F: Send + Clone + Sync> GetTracker<F, PaymentData<F>, api::PaymentsRetrieveRequest>
for PaymentStatus
{
#[instrument(skip_all)]
async fn get_trackers<'a>(
&'a self,
state: &'a SessionState,
payment_id: &api::PaymentIdType,
request: &api::PaymentsRetrieveRequest,
platform: &domain::Platform,
_auth_flow: services::AuthFlow,
_header_payload: &hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<
operations::GetTrackerResponse<'a, F, api::PaymentsRetrieveRequest, PaymentData<F>>,
> {
Box::pin(get_tracker_for_sync(
payment_id,
&platform.clone(),
state,
request,
self,
platform.get_processor().get_account().storage_scheme,
))
.await
}
}
#[cfg(feature = "v2")]
async fn get_tracker_for_sync<
'a,
F: Send + Clone,
Op: Operation<F, api::PaymentsRetrieveRequest, Data = PaymentData<F>> + 'a + Send + Sync,
>(
_payment_id: &api::PaymentIdType,
_platform: &domain::Platform,
_state: &SessionState,
_request: &api::PaymentsRetrieveRequest,
_operation: Op,
_storage_scheme: enums::MerchantStorageScheme,
) -> RouterResult<operations::GetTrackerResponse<'a, F, api::PaymentsRetrieveRequest, PaymentData<F>>>
{
todo!()
}
#[cfg(feature = "v1")]
#[allow(clippy::too_many_arguments)]
async fn get_tracker_for_sync<
'a,
F: Send + Clone,
Op: Operation<F, api::PaymentsRetrieveRequest, Data = PaymentData<F>> + 'a + Send + Sync,
>(
payment_id: &api::PaymentIdType,
platform: &domain::Platform,
state: &SessionState,
request: &api::PaymentsRetrieveRequest,
operation: Op,
storage_scheme: enums::MerchantStorageScheme,
) -> RouterResult<operations::GetTrackerResponse<'a, F, api::PaymentsRetrieveRequest, PaymentData<F>>>
{
let (payment_intent, mut payment_attempt, currency, amount);
(payment_intent, payment_attempt) = get_payment_intent_payment_attempt(
state,
payment_id,
platform.get_processor().get_account().get_id(),
platform.get_processor().get_key_store(),
storage_scheme,
)
.await?;
helpers::authenticate_client_secret(request.client_secret.as_ref(), &payment_intent)?;
let payment_id = payment_attempt.payment_id.clone();
currency = payment_attempt.currency.get_required_value("currency")?;
amount = payment_attempt.get_total_amount().into();
let shipping_address = helpers::get_address_by_id(
state,
payment_intent.shipping_address_id.clone(),
platform.get_processor().get_key_store(),
&payment_intent.payment_id.clone(),
platform.get_processor().get_account().get_id(),
platform.get_processor().get_account().storage_scheme,
)
.await?;
let billing_address = helpers::get_address_by_id(
state,
payment_intent.billing_address_id.clone(),
platform.get_processor().get_key_store(),
&payment_intent.payment_id.clone(),
platform.get_processor().get_account().get_id(),
platform.get_processor().get_account().storage_scheme,
)
.await?;
let payment_method_billing = helpers::get_address_by_id(
state,
payment_attempt.payment_method_billing_address_id.clone(),
platform.get_processor().get_key_store(),
&payment_intent.payment_id.clone(),
platform.get_processor().get_account().get_id(),
platform.get_processor().get_account().storage_scheme,
)
.await?;
payment_attempt.encoded_data.clone_from(&request.param);
let db = &*state.store;
let attempts = match request.expand_attempts {
Some(true) => {
Some(db
.find_attempts_by_merchant_id_payment_id(platform.get_processor().get_account().get_id(), &payment_id, storage_scheme, platform.get_processor().get_key_store())
.await
.change_context(errors::ApiErrorResponse::PaymentNotFound)
.attach_printable_lazy(|| {
format!("Error while retrieving attempt list for, merchant_id: {:?}, payment_id: {payment_id:?}",platform.get_processor().get_account().get_id())
})?)
},
_ => None,
};
let multiple_capture_data = if payment_attempt.multiple_capture_count > Some(0) {
let captures = db
.find_all_captures_by_merchant_id_payment_id_authorized_attempt_id(
&payment_attempt.merchant_id,
&payment_attempt.payment_id,
&payment_attempt.attempt_id,
storage_scheme,
)
.await
.change_context(errors::ApiErrorResponse::PaymentNotFound)
.attach_printable_lazy(|| {
format!("Error while retrieving capture list for, merchant_id: {:?}, payment_id: {payment_id:?}", platform.get_processor().get_account().get_id())
})?;
Some(payment_types::MultipleCaptureData::new_for_sync(
captures,
request.expand_captures,
)?)
} else {
None
};
let refunds = db
.find_refund_by_payment_id_merchant_id(
&payment_id,
platform.get_processor().get_account().get_id(),
storage_scheme,
)
.await
.change_context(errors::ApiErrorResponse::PaymentNotFound)
.attach_printable_lazy(|| {
format!(
"Failed while getting refund list for, payment_id: {:?}, merchant_id: {:?}",
&payment_id,
platform.get_processor().get_account().get_id()
)
})?;
let authorizations = db
.find_all_authorizations_by_merchant_id_payment_id(
platform.get_processor().get_account().get_id(),
&payment_id,
)
.await
.change_context(errors::ApiErrorResponse::PaymentNotFound)
.attach_printable_lazy(|| {
format!(
"Failed while getting authorizations list for, payment_id: {:?}, merchant_id: {:?}",
&payment_id,
platform.get_processor().get_account().get_id()
)
})?;
let disputes = db
.find_disputes_by_merchant_id_payment_id(platform.get_processor().get_account().get_id(), &payment_id)
.await
.change_context(errors::ApiErrorResponse::PaymentNotFound)
.attach_printable_lazy(|| {
format!("Error while retrieving dispute list for, merchant_id: {:?}, payment_id: {payment_id:?}", platform.get_processor().get_account().get_id())
})?;
let frm_response = if cfg!(feature = "frm") {
db.find_fraud_check_by_payment_id(payment_id.to_owned(), platform.get_processor().get_account().get_id().clone())
.await
.change_context(errors::ApiErrorResponse::PaymentNotFound)
.attach_printable_lazy(|| {
format!("Error while retrieving frm_response, merchant_id: {:?}, payment_id: {payment_id:?}", platform.get_processor().get_account().get_id())
})
.ok()
} else {
None
};
let contains_encoded_data = payment_attempt.encoded_data.is_some();
let creds_identifier = request
.merchant_connector_details
.as_ref()
.map(|mcd| mcd.creds_identifier.to_owned());
request
.merchant_connector_details
.to_owned()
.async_map(|mcd| async {
helpers::insert_merchant_connector_creds_to_config(db, platform.get_processor(), mcd)
.await
})
.await
.transpose()?;
let profile_id = payment_intent
.profile_id
.as_ref()
.get_required_value("profile_id")
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("'profile_id' not set in payment intent")?;
let business_profile = db
.find_business_profile_by_profile_id(platform.get_processor().get_key_store(), profile_id)
.await
.to_not_found_response(errors::ApiErrorResponse::ProfileNotFound {
id: profile_id.get_string_repr().to_owned(),
})?;
let payment_method_info =
if let Some(ref payment_method_id) = payment_attempt.payment_method_id.clone() {
match db
.find_payment_method(
platform.get_processor().get_key_store(),
payment_method_id,
storage_scheme,
)
.await
{
Ok(payment_method) => Some(payment_method),
Err(error) => {
if error.current_context().is_db_not_found() {
logger::info!("Payment Method not found in db {:?}", error);
None
} else {
Err(error)
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Error retrieving payment method from db")?
}
}
}
} else {
None
};
let merchant_id = payment_intent.merchant_id.clone();
let key_manager_state = &(state).into();
let authentication_store =
if let Some(ref authentication_id) = payment_attempt.authentication_id {
let authentication = db
.find_authentication_by_merchant_id_authentication_id(
&merchant_id,
authentication_id,
platform.get_processor().get_key_store(),
key_manager_state,
)
.await
.to_not_found_response(errors::ApiErrorResponse::InternalServerError)
.attach_printable_lazy(|| {
format!(
"Error while fetching authentication record with authentication_id {}",
authentication_id.get_string_repr()
)
})?;
Some(
hyperswitch_domain_models::router_request_types::authentication::AuthenticationStore {
authentication,
cavv: None, // marking this as None since we don't need authentication value in payment status flow
},
)
} else {
None
};
let payment_link_data = payment_intent
.payment_link_id
.as_ref()
.async_map(|id| crate::core::payments::get_payment_link_response_from_id(state, id))
.await
.transpose()?;
let payment_data = PaymentData {
flow: PhantomData,
payment_intent,
currency,
amount,
email: None,
mandate_id: payment_attempt
.mandate_id
.clone()
.map(|id| api_models::payments::MandateIds {
mandate_id: Some(id),
mandate_reference_id: None,
}),
mandate_connector: None,
setup_mandate: None,
customer_acceptance: None,
token: None,
address: PaymentAddress::new(
shipping_address.as_ref().map(From::from),
billing_address.as_ref().map(From::from),
payment_method_billing.as_ref().map(From::from),
business_profile.use_billing_as_payment_method_billing,
),
token_data: None,
confirm: Some(request.force_sync),
payment_method_data: None,
payment_method_token: None,
payment_method_info,
force_sync: Some(
request.force_sync
&& (helpers::check_force_psync_precondition(payment_attempt.status)
|| contains_encoded_data),
),
all_keys_required: request.all_keys_required,
payment_attempt,
refunds,
disputes,
attempts,
sessions_token: vec![],
card_cvc: None,
creds_identifier,
pm_token: None,
connector_customer_id: None,
recurring_mandate_payment_data: None,
multiple_capture_data,
redirect_response: None,
payment_link_data,
surcharge_details: None,
frm_message: frm_response,
incremental_authorization_details: None,
authorizations,
authentication: authentication_store,
recurring_details: None,
poll_config: None,
tax_data: None,
session_id: None,
service_details: None,
card_testing_guard_data: None,
vault_operation: None,
threeds_method_comp_ind: None,
whole_connector_response: None,
is_manual_retry_enabled: business_profile.is_manual_retry_enabled,
is_l2_l3_enabled: business_profile.is_l2_l3_enabled,
external_authentication_data: None,
};
let get_trackers_response = operations::GetTrackerResponse {
operation: Box::new(operation),
customer_details: None,
payment_data,
business_profile,
mandate_type: None,
};
Ok(get_trackers_response)
}
impl<F: Send + Clone + Sync> ValidateRequest<F, api::PaymentsRetrieveRequest, PaymentData<F>>
for PaymentStatus
{
fn validate_request<'b>(
&'b self,
request: &api::PaymentsRetrieveRequest,
processor: &domain::Processor,
) -> RouterResult<(
PaymentStatusOperation<'b, F, api::PaymentsRetrieveRequest>,
operations::ValidateResult,
)> {
let request_merchant_id = request.merchant_id.as_ref();
helpers::validate_merchant_id(processor.get_account().get_id(), request_merchant_id)
.change_context(errors::ApiErrorResponse::InvalidDataFormat {
field_name: "merchant_id".to_string(),
expected_format: "merchant_id from merchant account".to_string(),
})?;
Ok((
Box::new(self),
operations::ValidateResult {
merchant_id: processor.get_account().get_id().to_owned(),
payment_id: request.resource_id.clone(),
storage_scheme: processor.get_account().storage_scheme,
requeue: false,
},
))
}
}
pub async fn get_payment_intent_payment_attempt(
state: &SessionState,
payment_id: &api::PaymentIdType,
merchant_id: &common_utils::id_type::MerchantId,
key_store: &domain::MerchantKeyStore,
storage_scheme: enums::MerchantStorageScheme,
) -> RouterResult<(storage::PaymentIntent, storage::PaymentAttempt)> {
let db = &*state.store;
let get_pi_pa = || async {
let (pi, pa);
match payment_id {
api_models::payments::PaymentIdType::PaymentIntentId(ref id) => {
pi = db
.find_payment_intent_by_payment_id_merchant_id(
id,
merchant_id,
key_store,
storage_scheme,
)
.await?;
pa = db
.find_payment_attempt_by_payment_id_merchant_id_attempt_id(
&pi.payment_id,
merchant_id,
pi.active_attempt.get_id().as_str(),
storage_scheme,
key_store,
)
.await?;
}
api_models::payments::PaymentIdType::ConnectorTransactionId(ref id) => {
pa = db
.find_payment_attempt_by_merchant_id_connector_txn_id(
merchant_id,
id,
storage_scheme,
key_store,
)
.await?;
pi = db
.find_payment_intent_by_payment_id_merchant_id(
&pa.payment_id,
merchant_id,
key_store,
storage_scheme,
)
.await?;
}
api_models::payments::PaymentIdType::PaymentAttemptId(ref id) => {
pa = db
.find_payment_attempt_by_attempt_id_merchant_id(
id,
merchant_id,
storage_scheme,
key_store,
)
.await?;
pi = db
.find_payment_intent_by_payment_id_merchant_id(
&pa.payment_id,
merchant_id,
key_store,
storage_scheme,
)
.await?;
}
api_models::payments::PaymentIdType::PreprocessingId(ref id) => {
pa = db
.find_payment_attempt_by_preprocessing_id_merchant_id(
id,
merchant_id,
storage_scheme,
key_store,
)
.await?;
pi = db
.find_payment_intent_by_payment_id_merchant_id(
&pa.payment_id,
merchant_id,
key_store,
storage_scheme,
)
.await?;
}
}
error_stack::Result::<_, errors::StorageError>::Ok((pi, pa))
};
get_pi_pa()
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)
// TODO (#7195): Add platform merchant account validation once client_secret auth is solved
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/payments/operations/tax_calculation.rs | crates/router/src/core/payments/operations/tax_calculation.rs | use std::marker::PhantomData;
use api_models::enums::FrmSuggestion;
use async_trait::async_trait;
use common_utils::ext_traits::AsyncExt;
use error_stack::ResultExt;
use masking::PeekInterface;
use router_derive::PaymentOperation;
use router_env::{instrument, tracing};
use super::{BoxedOperation, Domain, GetTracker, Operation, UpdateTracker, ValidateRequest};
use crate::{
core::{
errors::{self, RouterResult, StorageErrorExt},
payment_methods::cards::create_encrypted_data,
payments::{self, helpers, operations, PaymentData, PaymentMethodChecker},
utils as core_utils,
},
db::errors::ConnectorErrorExt,
routes::{app::ReqState, SessionState},
services,
types::{
self,
api::{self, ConnectorCallType, PaymentIdTypeExt},
domain,
storage::{self, enums as storage_enums},
},
utils::OptionExt,
};
#[derive(Debug, Clone, Copy, PaymentOperation)]
#[operation(operations = "all", flow = "sdk_session_update")]
pub struct PaymentSessionUpdate;
type PaymentSessionUpdateOperation<'b, F> =
BoxedOperation<'b, F, api::PaymentsDynamicTaxCalculationRequest, PaymentData<F>>;
#[async_trait]
impl<F: Send + Clone + Sync>
GetTracker<F, PaymentData<F>, api::PaymentsDynamicTaxCalculationRequest>
for PaymentSessionUpdate
{
#[instrument(skip_all)]
async fn get_trackers<'a>(
&'a self,
state: &'a SessionState,
payment_id: &api::PaymentIdType,
request: &api::PaymentsDynamicTaxCalculationRequest,
platform: &domain::Platform,
_auth_flow: services::AuthFlow,
_header_payload: &hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<
operations::GetTrackerResponse<
'a,
F,
api::PaymentsDynamicTaxCalculationRequest,
PaymentData<F>,
>,
> {
let payment_id = payment_id
.get_payment_intent_id()
.change_context(errors::ApiErrorResponse::PaymentNotFound)?;
let db = &*state.store;
let merchant_id = platform.get_processor().get_account().get_id();
let storage_scheme = platform.get_processor().get_account().storage_scheme;
let payment_intent = db
.find_payment_intent_by_payment_id_merchant_id(
&payment_id,
merchant_id,
platform.get_processor().get_key_store(),
storage_scheme,
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
// TODO (#7195): Add platform merchant account validation once publishable key auth is solved
helpers::validate_payment_status_against_not_allowed_statuses(
payment_intent.status,
&[
storage_enums::IntentStatus::Failed,
storage_enums::IntentStatus::Succeeded,
],
"create a session update for",
)?;
helpers::authenticate_client_secret(Some(request.client_secret.peek()), &payment_intent)?;
let mut payment_attempt = db
.find_payment_attempt_by_payment_id_merchant_id_attempt_id(
&payment_intent.payment_id,
merchant_id,
payment_intent.active_attempt.get_id().as_str(),
storage_scheme,
platform.get_processor().get_key_store(),
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
let currency = payment_intent.currency.get_required_value("currency")?;
let amount = payment_attempt.get_total_amount().into();
payment_attempt.payment_method_type = Some(request.payment_method_type);
let shipping_address = helpers::get_address_by_id(
state,
payment_intent.shipping_address_id.clone(),
platform.get_processor().get_key_store(),
&payment_intent.payment_id,
merchant_id,
platform.get_processor().get_account().storage_scheme,
)
.await?;
let profile_id = payment_intent
.profile_id
.as_ref()
.get_required_value("profile_id")
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("'profile_id' not set in payment intent")?;
let business_profile = db
.find_business_profile_by_profile_id(
platform.get_processor().get_key_store(),
profile_id,
)
.await
.to_not_found_response(errors::ApiErrorResponse::ProfileNotFound {
id: profile_id.get_string_repr().to_owned(),
})?;
let tax_data = payments::TaxData {
shipping_details: request.shipping.clone().into(),
payment_method_type: request.payment_method_type,
};
let payment_data = PaymentData {
flow: PhantomData,
payment_intent,
payment_attempt,
currency,
amount,
email: None,
mandate_id: None,
mandate_connector: None,
customer_acceptance: None,
token: None,
token_data: None,
setup_mandate: None,
address: payments::PaymentAddress::new(
shipping_address.as_ref().map(From::from),
None,
None,
business_profile.use_billing_as_payment_method_billing,
),
confirm: None,
payment_method_data: None,
payment_method_token: None,
payment_method_info: None,
force_sync: None,
all_keys_required: None,
refunds: vec![],
disputes: vec![],
attempts: None,
sessions_token: vec![],
card_cvc: None,
creds_identifier: None,
pm_token: None,
connector_customer_id: None,
recurring_mandate_payment_data: None,
multiple_capture_data: None,
redirect_response: None,
surcharge_details: None,
frm_message: None,
payment_link_data: None,
incremental_authorization_details: None,
authorizations: vec![],
authentication: None,
recurring_details: None,
poll_config: None,
tax_data: Some(tax_data),
session_id: request.session_id.clone(),
service_details: None,
card_testing_guard_data: None,
vault_operation: None,
threeds_method_comp_ind: None,
whole_connector_response: None,
is_manual_retry_enabled: None,
is_l2_l3_enabled: false,
external_authentication_data: None,
};
let get_trackers_response = operations::GetTrackerResponse {
operation: Box::new(self),
customer_details: None,
payment_data,
business_profile,
mandate_type: None,
};
Ok(get_trackers_response)
}
}
#[async_trait]
impl<F: Clone + Send + Sync> Domain<F, api::PaymentsDynamicTaxCalculationRequest, PaymentData<F>>
for PaymentSessionUpdate
{
#[instrument(skip_all)]
async fn populate_raw_customer_details<'a>(
&'a self,
_state: &SessionState,
_payment_data: &mut PaymentData<F>,
_request: Option<&payments::CustomerDetails>,
_processor: &domain::Processor,
) -> errors::CustomResult<(), errors::StorageError> {
Ok(())
}
#[instrument(skip_all)]
async fn get_or_create_customer_details<'a>(
&'a self,
_state: &SessionState,
_payment_data: &mut PaymentData<F>,
_request: Option<payments::CustomerDetails>,
_provider: &domain::Provider,
) -> errors::CustomResult<
(
PaymentSessionUpdateOperation<'a, F>,
Option<domain::Customer>,
),
errors::StorageError,
> {
Ok((Box::new(self), None))
}
async fn payments_dynamic_tax_calculation<'a>(
&'a self,
state: &SessionState,
payment_data: &mut PaymentData<F>,
_connector_call_type: &ConnectorCallType,
business_profile: &domain::Profile,
platform: &domain::Platform,
) -> errors::CustomResult<(), errors::ApiErrorResponse> {
let is_tax_connector_enabled = business_profile.get_is_tax_connector_enabled();
let skip_external_tax_calculation = payment_data
.payment_intent
.skip_external_tax_calculation
.unwrap_or(false);
if is_tax_connector_enabled && !skip_external_tax_calculation {
let db = state.store.as_ref();
let merchant_connector_id = business_profile
.tax_connector_id
.as_ref()
.get_required_value("business_profile.tax_connector_id")?;
#[cfg(feature = "v1")]
let mca = db
.find_by_merchant_connector_account_merchant_id_merchant_connector_id(
&business_profile.merchant_id,
merchant_connector_id,
platform.get_processor().get_key_store(),
)
.await
.to_not_found_response(
errors::ApiErrorResponse::MerchantConnectorAccountNotFound {
id: merchant_connector_id.get_string_repr().to_string(),
},
)?;
#[cfg(feature = "v2")]
let mca = db
.find_merchant_connector_account_by_id(merchant_connector_id, key_store)
.await
.to_not_found_response(
errors::ApiErrorResponse::MerchantConnectorAccountNotFound {
id: merchant_connector_id.get_string_repr().to_string(),
},
)?;
let connector_data =
api::TaxCalculateConnectorData::get_connector_by_name(&mca.connector_name)?;
let router_data = core_utils::construct_payments_dynamic_tax_calculation_router_data(
state,
platform,
payment_data,
&mca,
)
.await?;
let connector_integration: services::BoxedPaymentConnectorIntegrationInterface<
api::CalculateTax,
types::PaymentsTaxCalculationData,
types::TaxCalculationResponseData,
> = connector_data.connector.get_connector_integration();
let response = services::execute_connector_processing_step(
state,
connector_integration,
&router_data,
payments::CallConnectorAction::Trigger,
None,
None,
)
.await
.to_payment_failed_response()
.attach_printable("Tax connector Response Failed")?;
let tax_response = response.response.map_err(|err| {
errors::ApiErrorResponse::ExternalConnectorError {
code: err.code,
message: err.message,
connector: connector_data.connector_name.clone().to_string(),
status_code: err.status_code,
reason: err.reason,
}
})?;
let payment_method_type = payment_data
.tax_data
.clone()
.map(|tax_data| tax_data.payment_method_type)
.ok_or(errors::ApiErrorResponse::InternalServerError)
.attach_printable("missing tax_data.payment_method_type")?;
payment_data.payment_intent.tax_details = Some(diesel_models::TaxDetails {
payment_method_type: Some(diesel_models::PaymentMethodTypeTax {
order_tax_amount: tax_response.order_tax_amount,
pmt: payment_method_type,
}),
default: None,
});
Ok(())
} else {
Ok(())
}
}
#[instrument(skip_all)]
async fn make_pm_data<'a>(
&'a self,
_state: &'a SessionState,
_payment_data: &mut PaymentData<F>,
_storage_scheme: storage_enums::MerchantStorageScheme,
_merchant_key_store: &domain::MerchantKeyStore,
_customer: &Option<domain::Customer>,
_business_profile: &domain::Profile,
_should_retry_with_pan: bool,
) -> RouterResult<(
PaymentSessionUpdateOperation<'a, F>,
Option<domain::PaymentMethodData>,
Option<String>,
)> {
Ok((Box::new(self), None, None))
}
async fn get_connector<'a>(
&'a self,
_platform: &domain::Platform,
state: &SessionState,
_request: &api::PaymentsDynamicTaxCalculationRequest,
_payment_intent: &storage::PaymentIntent,
) -> errors::CustomResult<api::ConnectorChoice, errors::ApiErrorResponse> {
helpers::get_connector_default(state, None).await
}
#[instrument(skip_all)]
async fn guard_payment_against_blocklist<'a>(
&'a self,
_state: &SessionState,
_platform: &domain::Platform,
_payment_data: &mut PaymentData<F>,
) -> errors::CustomResult<bool, errors::ApiErrorResponse> {
Ok(false)
}
}
#[async_trait]
impl<F: Clone + Sync> UpdateTracker<F, PaymentData<F>, api::PaymentsDynamicTaxCalculationRequest>
for PaymentSessionUpdate
{
#[instrument(skip_all)]
async fn update_trackers<'b>(
&'b self,
state: &'b SessionState,
_req_state: ReqState,
processor: &domain::Processor,
mut payment_data: PaymentData<F>,
_customer: Option<domain::Customer>,
_frm_suggestion: Option<FrmSuggestion>,
_header_payload: hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<(PaymentSessionUpdateOperation<'b, F>, PaymentData<F>)>
where
F: 'b + Send,
{
let storage_scheme = processor.get_account().storage_scheme;
let key_store = processor.get_key_store();
// For Google Pay and Apple Pay, we don’t need to call the connector again; we can directly confirm the payment after tax_calculation. So, we update the required fields in the database during the update_tracker call.
if payment_data.should_update_in_update_tracker() {
let shipping_address = payment_data
.tax_data
.clone()
.map(|tax_data| tax_data.shipping_details);
let key_manager_state = state.into();
let shipping_details = shipping_address
.clone()
.async_map(|shipping_details| {
create_encrypted_data(&key_manager_state, key_store, shipping_details)
})
.await
.transpose()
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Unable to encrypt shipping details")?;
let shipping_address = helpers::create_or_update_address_for_payment_by_request(
state,
shipping_address.map(From::from).as_ref(),
payment_data.payment_intent.shipping_address_id.as_deref(),
&payment_data.payment_intent.merchant_id,
payment_data.payment_intent.customer_id.as_ref(),
key_store,
&payment_data.payment_intent.payment_id,
storage_scheme,
)
.await?;
let payment_intent_update = hyperswitch_domain_models::payments::payment_intent::PaymentIntentUpdate::SessionResponseUpdate {
tax_details: payment_data.payment_intent.tax_details.clone().ok_or(errors::ApiErrorResponse::InternalServerError).attach_printable("payment_intent.tax_details not found")?,
shipping_address_id: shipping_address.map(|address| address.address_id),
updated_by: payment_data.payment_intent.updated_by.clone(),
shipping_details,
};
let db = &*state.store;
let payment_intent = payment_data.payment_intent.clone();
let updated_payment_intent = db
.update_payment_intent(
payment_intent,
payment_intent_update,
key_store,
storage_scheme,
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
payment_data.payment_intent = updated_payment_intent;
Ok((Box::new(self), payment_data))
} else {
Ok((Box::new(self), payment_data))
}
}
}
impl<F: Send + Clone + Sync>
ValidateRequest<F, api::PaymentsDynamicTaxCalculationRequest, PaymentData<F>>
for PaymentSessionUpdate
{
#[instrument(skip_all)]
fn validate_request<'a, 'b>(
&'b self,
request: &api::PaymentsDynamicTaxCalculationRequest,
processor: &'a domain::Processor,
) -> RouterResult<(
PaymentSessionUpdateOperation<'b, F>,
operations::ValidateResult,
)> {
//paymentid is already generated and should be sent in the request
let given_payment_id = request.payment_id.clone();
Ok((
Box::new(self),
operations::ValidateResult {
merchant_id: processor.get_account().get_id().to_owned(),
payment_id: api::PaymentIdType::PaymentIntentId(given_payment_id),
storage_scheme: processor.get_account().storage_scheme,
requeue: false,
},
))
}
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/payments/operations/payment_capture_v2.rs | crates/router/src/core/payments/operations/payment_capture_v2.rs | use api_models::{enums::FrmSuggestion, payments::PaymentsCaptureRequest};
use async_trait::async_trait;
use error_stack::ResultExt;
use hyperswitch_domain_models::payments::PaymentCaptureData;
use router_env::{instrument, tracing};
use super::{Domain, GetTracker, Operation, UpdateTracker, ValidateRequest};
use crate::{
core::{
errors::{self, CustomResult, RouterResult, StorageErrorExt},
payments::{
helpers,
operations::{self, ValidateStatusForOperation},
},
},
routes::{app::ReqState, SessionState},
types::{
api::{self, ConnectorCallType},
domain::{self},
storage::{self, enums as storage_enums},
},
utils::OptionExt,
};
#[derive(Debug, Clone, Copy)]
pub struct PaymentsCapture;
impl ValidateStatusForOperation for PaymentsCapture {
/// Validate if the current operation can be performed on the current status of the payment intent
fn validate_status_for_operation(
&self,
intent_status: common_enums::IntentStatus,
) -> Result<(), errors::ApiErrorResponse> {
match intent_status {
common_enums::IntentStatus::RequiresCapture
| common_enums::IntentStatus::PartiallyAuthorizedAndRequiresCapture
| common_enums::IntentStatus::PartiallyCapturedAndCapturable => Ok(()),
common_enums::IntentStatus::Succeeded
| common_enums::IntentStatus::Conflicted
| common_enums::IntentStatus::Failed
| common_enums::IntentStatus::Cancelled
| common_enums::IntentStatus::CancelledPostCapture
| common_enums::IntentStatus::Processing
| common_enums::IntentStatus::PartiallyCapturedAndProcessing
| common_enums::IntentStatus::RequiresCustomerAction
| common_enums::IntentStatus::RequiresMerchantAction
| common_enums::IntentStatus::RequiresPaymentMethod
| common_enums::IntentStatus::PartiallyCaptured
| common_enums::IntentStatus::RequiresConfirmation
| common_enums::IntentStatus::Expired => {
Err(errors::ApiErrorResponse::PaymentUnexpectedState {
current_flow: format!("{self:?}"),
field_name: "status".to_string(),
current_value: intent_status.to_string(),
states: [
common_enums::IntentStatus::RequiresCapture,
common_enums::IntentStatus::PartiallyCapturedAndCapturable,
]
.map(|enum_value| enum_value.to_string())
.join(", "),
})
}
}
}
}
type BoxedConfirmOperation<'b, F> =
super::BoxedOperation<'b, F, PaymentsCaptureRequest, PaymentCaptureData<F>>;
// TODO: change the macro to include changes for v2
// TODO: PaymentData in the macro should be an input
impl<F: Send + Clone> Operation<F, PaymentsCaptureRequest> for &PaymentsCapture {
type Data = PaymentCaptureData<F>;
fn to_validate_request(
&self,
) -> RouterResult<&(dyn ValidateRequest<F, PaymentsCaptureRequest, Self::Data> + Send + Sync)>
{
Ok(*self)
}
fn to_get_tracker(
&self,
) -> RouterResult<&(dyn GetTracker<F, Self::Data, PaymentsCaptureRequest> + Send + Sync)> {
Ok(*self)
}
fn to_domain(&self) -> RouterResult<&(dyn Domain<F, PaymentsCaptureRequest, Self::Data>)> {
Ok(*self)
}
fn to_update_tracker(
&self,
) -> RouterResult<&(dyn UpdateTracker<F, Self::Data, PaymentsCaptureRequest> + Send + Sync)>
{
Ok(*self)
}
}
#[automatically_derived]
impl<F: Send + Clone> Operation<F, PaymentsCaptureRequest> for PaymentsCapture {
type Data = PaymentCaptureData<F>;
fn to_validate_request(
&self,
) -> RouterResult<&(dyn ValidateRequest<F, PaymentsCaptureRequest, Self::Data> + Send + Sync)>
{
Ok(self)
}
fn to_get_tracker(
&self,
) -> RouterResult<&(dyn GetTracker<F, Self::Data, PaymentsCaptureRequest> + Send + Sync)> {
Ok(self)
}
fn to_domain(&self) -> RouterResult<&dyn Domain<F, PaymentsCaptureRequest, Self::Data>> {
Ok(self)
}
fn to_update_tracker(
&self,
) -> RouterResult<&(dyn UpdateTracker<F, Self::Data, PaymentsCaptureRequest> + Send + Sync)>
{
Ok(self)
}
}
impl<F: Send + Clone> ValidateRequest<F, PaymentsCaptureRequest, PaymentCaptureData<F>>
for PaymentsCapture
{
#[instrument(skip_all)]
fn validate_request<'a, 'b>(
&'b self,
_request: &PaymentsCaptureRequest,
platform: &'a domain::Platform,
) -> RouterResult<operations::ValidateResult> {
let validate_result = operations::ValidateResult {
merchant_id: platform.get_processor().get_account().get_id().to_owned(),
storage_scheme: platform.get_processor().get_account().storage_scheme,
requeue: false,
};
Ok(validate_result)
}
}
#[async_trait]
impl<F: Send + Clone> GetTracker<F, PaymentCaptureData<F>, PaymentsCaptureRequest>
for PaymentsCapture
{
#[instrument(skip_all)]
async fn get_trackers<'a>(
&'a self,
state: &'a SessionState,
payment_id: &common_utils::id_type::GlobalPaymentId,
request: &PaymentsCaptureRequest,
platform: &domain::Platform,
_profile: &domain::Profile,
_header_payload: &hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<operations::GetTrackerResponse<PaymentCaptureData<F>>> {
let db = &*state.store;
let storage_scheme = platform.get_processor().get_account().storage_scheme;
let payment_intent = db
.find_payment_intent_by_id(
payment_id,
platform.get_processor().get_key_store(),
storage_scheme,
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
self.validate_status_for_operation(payment_intent.status)?;
let active_attempt_id = payment_intent
.active_attempt_id
.as_ref()
.get_required_value("active_attempt_id")
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Active attempt id is none when capturing the payment")?;
let mut payment_attempt = db
.find_payment_attempt_by_id(
platform.get_processor().get_key_store(),
active_attempt_id,
storage_scheme,
)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Could not find payment attempt given the attempt id")?;
if let Some(amount_to_capture) = request.amount_to_capture {
payment_attempt
.amount_details
.validate_amount_to_capture(amount_to_capture)
.change_context(errors::ApiErrorResponse::PreconditionFailed {
message: format!(
"`amount_to_capture` is greater than the net amount {}",
payment_attempt.amount_details.get_net_amount()
),
})?;
payment_attempt
.amount_details
.set_amount_to_capture(amount_to_capture);
}
let payment_data = PaymentCaptureData {
flow: std::marker::PhantomData,
payment_intent,
payment_attempt,
};
let get_trackers_response = operations::GetTrackerResponse { payment_data };
Ok(get_trackers_response)
}
}
#[async_trait]
impl<F: Clone + Send> Domain<F, PaymentsCaptureRequest, PaymentCaptureData<F>> for PaymentsCapture {
async fn get_customer_details<'a>(
&'a self,
state: &SessionState,
payment_data: &mut PaymentCaptureData<F>,
merchant_key_store: &domain::MerchantKeyStore,
storage_scheme: storage_enums::MerchantStorageScheme,
) -> CustomResult<(BoxedConfirmOperation<'a, F>, Option<domain::Customer>), errors::StorageError>
{
match payment_data.payment_intent.customer_id.clone() {
Some(id) => {
let customer = state
.store
.find_customer_by_global_id(&id, merchant_key_store, storage_scheme)
.await?;
Ok((Box::new(self), Some(customer)))
}
None => Ok((Box::new(self), None)),
}
}
#[instrument(skip_all)]
async fn make_pm_data<'a>(
&'a self,
_state: &'a SessionState,
_payment_data: &mut PaymentCaptureData<F>,
_storage_scheme: storage_enums::MerchantStorageScheme,
_key_store: &domain::MerchantKeyStore,
_customer: &Option<domain::Customer>,
_business_profile: &domain::Profile,
_should_retry_with_pan: bool,
) -> RouterResult<(
BoxedConfirmOperation<'a, F>,
Option<domain::PaymentMethodData>,
Option<String>,
)> {
Ok((Box::new(self), None, None))
}
#[instrument(skip_all)]
async fn perform_routing<'a>(
&'a self,
_platform: &domain::Platform,
_business_profile: &domain::Profile,
state: &SessionState,
// TODO: do not take the whole payment data here
payment_data: &mut PaymentCaptureData<F>,
) -> CustomResult<ConnectorCallType, errors::ApiErrorResponse> {
let payment_attempt = &payment_data.payment_attempt;
let connector = payment_attempt
.connector
.as_ref()
.get_required_value("connector")
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Connector is none when constructing response")?;
let merchant_connector_id = payment_attempt
.merchant_connector_id
.as_ref()
.get_required_value("merchant_connector_id")
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Merchant connector id is none when constructing response")?;
let connector_data = api::ConnectorData::get_connector_by_name(
&state.conf.connectors,
connector,
api::GetToken::Connector,
Some(merchant_connector_id.to_owned()),
)
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Invalid connector name received")?;
Ok(ConnectorCallType::PreDetermined(connector_data.into()))
}
}
#[async_trait]
impl<F: Clone> UpdateTracker<F, PaymentCaptureData<F>, PaymentsCaptureRequest> for PaymentsCapture {
#[instrument(skip_all)]
async fn update_trackers<'b>(
&'b self,
state: &'b SessionState,
_req_state: ReqState,
processor: &domain::Processor,
mut payment_data: PaymentCaptureData<F>,
_customer: Option<domain::Customer>,
_frm_suggestion: Option<FrmSuggestion>,
_header_payload: hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<(BoxedConfirmOperation<'b, F>, PaymentCaptureData<F>)>
where
F: 'b + Send,
{
let storage_scheme = processor.get_account().storage_scheme;
let key_store = processor.get_key_store();
let payment_attempt_update = hyperswitch_domain_models::payments::payment_attempt::PaymentAttemptUpdate::PreCaptureUpdate { amount_to_capture: payment_data.payment_attempt.amount_details.get_amount_to_capture(), updated_by: storage_scheme.to_string() };
let payment_attempt = state
.store
.update_payment_attempt(
key_store,
payment_data.payment_attempt.clone(),
payment_attempt_update,
storage_scheme,
)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Could not update payment attempt")?;
payment_data.payment_attempt = payment_attempt;
Ok((Box::new(self), payment_data))
}
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/payments/operations/payment_update.rs | crates/router/src/core/payments/operations/payment_update.rs | use std::marker::PhantomData;
use api_models::{
enums::FrmSuggestion, mandates::RecurringDetails, payments::RequestSurchargeDetails,
};
use async_trait::async_trait;
use common_utils::{
ext_traits::{AsyncExt, Encode, ValueExt},
pii::Email,
};
use error_stack::{report, ResultExt};
use hyperswitch_domain_models::payments::payment_intent::{
CustomerData, PaymentIntentUpdateFields,
};
use router_derive::PaymentOperation;
use router_env::{instrument, tracing};
use super::{BoxedOperation, Domain, GetTracker, Operation, UpdateTracker, ValidateRequest};
use crate::{
core::{
errors::{self, CustomResult, RouterResult, StorageErrorExt},
mandate::helpers as m_helpers,
payment_methods::cards::create_encrypted_data,
payments::{self, helpers, operations, CustomerDetails, PaymentAddress, PaymentData},
utils as core_utils,
},
events::audit_events::{AuditEvent, AuditEventType},
routes::{app::ReqState, SessionState},
services,
types::{
self,
api::{self, ConnectorCallType, PaymentIdTypeExt},
domain,
storage::{self, enums as storage_enums, payment_attempt::PaymentAttemptExt},
transformers::ForeignTryFrom,
},
utils::OptionExt,
};
#[derive(Debug, Clone, Copy, PaymentOperation)]
#[operation(operations = "all", flow = "authorize")]
pub struct PaymentUpdate;
type PaymentUpdateOperation<'a, F> = BoxedOperation<'a, F, api::PaymentsRequest, PaymentData<F>>;
#[async_trait]
impl<F: Send + Clone + Sync> GetTracker<F, PaymentData<F>, api::PaymentsRequest> for PaymentUpdate {
#[instrument(skip_all)]
async fn get_trackers<'a>(
&'a self,
state: &'a SessionState,
payment_id: &api::PaymentIdType,
request: &api::PaymentsRequest,
platform: &domain::Platform,
auth_flow: services::AuthFlow,
_header_payload: &hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<operations::GetTrackerResponse<'a, F, api::PaymentsRequest, PaymentData<F>>>
{
let (mut payment_intent, mut payment_attempt, currency): (_, _, storage_enums::Currency);
let payment_id = payment_id
.get_payment_intent_id()
.change_context(errors::ApiErrorResponse::PaymentNotFound)?;
let merchant_id = platform.get_processor().get_account().get_id();
let storage_scheme = platform.get_processor().get_account().storage_scheme;
let db = &*state.store;
helpers::allow_payment_update_enabled_for_client_auth(merchant_id, state, auth_flow)
.await?;
payment_intent = db
.find_payment_intent_by_payment_id_merchant_id(
&payment_id,
merchant_id,
platform.get_processor().get_key_store(),
storage_scheme,
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
// TODO (#7195): Add platform merchant account validation once publishable key auth is solved
if let Some(order_details) = &request.order_details {
helpers::validate_order_details_amount(
order_details.to_owned(),
payment_intent.amount,
false,
)?;
}
payment_intent.setup_future_usage = request
.setup_future_usage
.or(payment_intent.setup_future_usage);
helpers::validate_customer_access(&payment_intent, auth_flow, request)?;
helpers::validate_card_data(
request
.payment_method_data
.as_ref()
.and_then(|pmd| pmd.payment_method_data.clone()),
)?;
helpers::validate_payment_status_against_allowed_statuses(
payment_intent.status,
&[
storage_enums::IntentStatus::RequiresPaymentMethod,
storage_enums::IntentStatus::RequiresConfirmation,
],
"update",
)?;
helpers::authenticate_client_secret(request.client_secret.as_ref(), &payment_intent)?;
payment_intent.order_details = request
.get_order_details_as_value()
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed to convert order details to value")?
.or(payment_intent.order_details);
payment_attempt = db
.find_payment_attempt_by_payment_id_merchant_id_attempt_id(
&payment_intent.payment_id,
merchant_id,
payment_intent.active_attempt.get_id().as_str(),
storage_scheme,
platform.get_processor().get_key_store(),
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
let customer_acceptance = request.customer_acceptance.clone();
let recurring_details = request.recurring_details.clone();
let mandate_type = m_helpers::get_mandate_type(
request.mandate_data.clone(),
request.off_session,
payment_intent.setup_future_usage,
request.customer_acceptance.clone(),
request.payment_token.clone(),
payment_attempt.payment_method.or(request.payment_method),
)
.change_context(errors::ApiErrorResponse::MandateValidationFailed {
reason: "Expected one out of recurring_details and mandate_data but got both".into(),
})?;
let m_helpers::MandateGenericData {
token,
payment_method,
payment_method_type,
mandate_data,
recurring_mandate_payment_data,
mandate_connector,
payment_method_info,
} = Box::pin(helpers::get_token_pm_type_mandate_details(
state,
request,
mandate_type.to_owned(),
platform,
None,
payment_intent.customer_id.as_ref(),
))
.await?;
helpers::validate_amount_to_capture_and_capture_method(Some(&payment_attempt), request)?;
helpers::validate_request_amount_and_amount_to_capture(
request.amount,
request.amount_to_capture,
request
.surcharge_details
.or(payment_attempt.get_surcharge_details()),
)
.change_context(errors::ApiErrorResponse::InvalidDataFormat {
field_name: "amount_to_capture".to_string(),
expected_format: "amount_to_capture lesser than or equal to amount".to_string(),
})?;
currency = request
.currency
.or(payment_attempt.currency)
.get_required_value("currency")?;
payment_attempt.payment_method = payment_method.or(payment_attempt.payment_method);
payment_attempt.payment_method_type =
payment_method_type.or(payment_attempt.payment_method_type);
let customer_details = helpers::get_customer_details_from_request(request);
let amount = request
.amount
.unwrap_or_else(|| payment_attempt.net_amount.get_order_amount().into());
if request.confirm.unwrap_or(false) {
helpers::validate_customer_id_mandatory_cases(
request.setup_future_usage.is_some(),
payment_intent
.customer_id
.as_ref()
.or(customer_details.customer_id.as_ref()),
)?;
}
let shipping_address = helpers::create_or_update_address_for_payment_by_request(
state,
request.shipping.as_ref(),
payment_intent.shipping_address_id.as_deref(),
merchant_id,
payment_intent
.customer_id
.as_ref()
.or(customer_details.customer_id.as_ref()),
platform.get_processor().get_key_store(),
&payment_intent.payment_id,
platform.get_processor().get_account().storage_scheme,
)
.await?;
let billing_address = helpers::create_or_update_address_for_payment_by_request(
state,
request.billing.as_ref(),
payment_intent.billing_address_id.as_deref(),
merchant_id,
payment_intent
.customer_id
.as_ref()
.or(customer_details.customer_id.as_ref()),
platform.get_processor().get_key_store(),
&payment_intent.payment_id,
platform.get_processor().get_account().storage_scheme,
)
.await?;
let payment_method_billing = helpers::create_or_update_address_for_payment_by_request(
state,
request
.payment_method_data
.as_ref()
.and_then(|pmd| pmd.billing.as_ref()),
payment_attempt.payment_method_billing_address_id.as_deref(),
merchant_id,
payment_intent
.customer_id
.as_ref()
.or(customer_details.customer_id.as_ref()),
platform.get_processor().get_key_store(),
&payment_intent.payment_id,
platform.get_processor().get_account().storage_scheme,
)
.await?;
payment_intent.shipping_address_id = shipping_address.clone().map(|x| x.address_id);
payment_intent.billing_address_id = billing_address.clone().map(|x| x.address_id);
payment_attempt.payment_method_billing_address_id = payment_method_billing
.as_ref()
.map(|payment_method_billing| payment_method_billing.address_id.clone());
payment_intent.allowed_payment_method_types = request
.get_allowed_payment_method_types_as_value()
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Error converting allowed_payment_types to Value")?
.or(payment_intent.allowed_payment_method_types);
payment_intent.connector_metadata = request
.get_connector_metadata_as_value()
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Error converting connector_metadata to Value")?
.or(payment_intent.connector_metadata);
payment_intent.feature_metadata = request
.get_feature_metadata_as_value()
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Error converting feature_metadata to Value")?
.or(payment_intent.feature_metadata);
payment_intent.metadata = request.metadata.clone().or(payment_intent.metadata);
payment_intent.frm_metadata = request.frm_metadata.clone().or(payment_intent.frm_metadata);
payment_intent.psd2_sca_exemption_type = request
.psd2_sca_exemption_type
.or(payment_intent.psd2_sca_exemption_type);
Self::populate_payment_intent_with_request(&mut payment_intent, request);
let token = token.or_else(|| payment_attempt.payment_token.clone());
if request.confirm.unwrap_or(false) {
helpers::validate_pm_or_token_given(
&request.payment_method,
&request
.payment_method_data
.as_ref()
.and_then(|pmd| pmd.payment_method_data.clone()),
&request.payment_method_type,
&mandate_type,
&token,
&request.ctp_service_details,
)?;
}
let token_data = if let Some(token) = token.clone() {
Some(helpers::retrieve_payment_token_data(state, token, payment_method).await?)
} else {
None
};
let mandate_id = request
.mandate_id
.as_ref()
.or_else(|| {
request.recurring_details
.as_ref()
.and_then(|recurring_details| match recurring_details {
RecurringDetails::MandateId(id) => Some(id),
_ => None,
})
})
.async_and_then(|mandate_id| async {
let mandate = db
.find_mandate_by_merchant_id_mandate_id(merchant_id, mandate_id, platform.get_processor().get_account().storage_scheme)
.await
.change_context(errors::ApiErrorResponse::MandateNotFound);
Some(mandate.and_then(|mandate_obj| {
match (
mandate_obj.network_transaction_id,
mandate_obj.connector_mandate_ids,
) {
(Some(network_tx_id), _) => Ok(api_models::payments::MandateIds {
mandate_id: Some(mandate_obj.mandate_id),
mandate_reference_id: Some(
api_models::payments::MandateReferenceId::NetworkMandateId(
network_tx_id,
),
),
}),
(_, Some(connector_mandate_id)) => connector_mandate_id
.parse_value("ConnectorMandateId")
.change_context(errors::ApiErrorResponse::MandateNotFound)
.map(|connector_id: api_models::payments::ConnectorMandateReferenceId| {
api_models::payments::MandateIds {
mandate_id: Some(mandate_obj.mandate_id),
mandate_reference_id: Some(api_models::payments::MandateReferenceId::ConnectorMandateId(
api_models::payments::ConnectorMandateReferenceId::new(
connector_id.get_connector_mandate_id(), // connector_mandate_id
connector_id.get_payment_method_id(), // payment_method_id
None, // update_history
connector_id.get_mandate_metadata(), // mandate_metadata
connector_id.get_connector_mandate_request_reference_id(),
None // connector_mandate_request_reference_id
)
))
}
}),
(_, _) => Ok(api_models::payments::MandateIds {
mandate_id: Some(mandate_obj.mandate_id),
mandate_reference_id: None,
}),
}
}))
})
.await
.transpose()?;
let (next_operation, amount): (PaymentUpdateOperation<'a, F>, _) =
if request.confirm.unwrap_or(false) {
let amount = {
let amount = request
.amount
.map(Into::into)
.unwrap_or(payment_attempt.net_amount.get_order_amount());
payment_attempt.net_amount.set_order_amount(amount);
payment_intent.amount = amount;
let surcharge_amount = request
.surcharge_details
.as_ref()
.map(RequestSurchargeDetails::get_total_surcharge_amount)
.or(payment_attempt.get_total_surcharge_amount());
amount + surcharge_amount.unwrap_or_default()
};
(Box::new(operations::PaymentConfirm), amount.into())
} else {
(Box::new(self), amount)
};
payment_intent.status = if request
.payment_method_data
.as_ref()
.is_some_and(|payment_method_data| payment_method_data.payment_method_data.is_some())
{
if request.confirm.unwrap_or(false) {
payment_intent.status
} else {
storage_enums::IntentStatus::RequiresConfirmation
}
} else {
storage_enums::IntentStatus::RequiresPaymentMethod
};
payment_intent.request_external_three_ds_authentication = request
.request_external_three_ds_authentication
.or(payment_intent.request_external_three_ds_authentication);
payment_intent.merchant_order_reference_id = request
.merchant_order_reference_id
.clone()
.or(payment_intent.merchant_order_reference_id);
Self::populate_payment_attempt_with_request(&mut payment_attempt, request);
let creds_identifier = request
.merchant_connector_details
.as_ref()
.map(|mcd| mcd.creds_identifier.to_owned());
request
.merchant_connector_details
.to_owned()
.async_map(|mcd| async {
helpers::insert_merchant_connector_creds_to_config(
db,
platform.get_processor(),
mcd,
)
.await
})
.await
.transpose()?;
// The operation merges mandate data from both request and payment_attempt
let setup_mandate = mandate_data;
let mandate_details_present =
payment_attempt.mandate_details.is_some() || request.mandate_data.is_some();
helpers::validate_mandate_data_and_future_usage(
payment_intent.setup_future_usage,
mandate_details_present,
)?;
let profile_id = payment_intent
.profile_id
.as_ref()
.get_required_value("profile_id")
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("'profile_id' not set in payment intent")?;
let business_profile = db
.find_business_profile_by_profile_id(
platform.get_processor().get_key_store(),
profile_id,
)
.await
.to_not_found_response(errors::ApiErrorResponse::ProfileNotFound {
id: profile_id.get_string_repr().to_owned(),
})?;
let surcharge_details = request.surcharge_details.map(|request_surcharge_details| {
payments::types::SurchargeDetails::from((&request_surcharge_details, &payment_attempt))
});
payment_intent.force_3ds_challenge = request
.force_3ds_challenge
.or(payment_intent.force_3ds_challenge);
payment_intent.payment_channel = request
.payment_channel
.clone()
.or(payment_intent.payment_channel);
payment_intent.enable_partial_authorization = request
.enable_partial_authorization
.or(payment_intent.enable_partial_authorization);
helpers::validate_overcapture_request(
&request.enable_overcapture,
&payment_attempt.capture_method,
)?;
payment_intent.enable_overcapture = request.enable_overcapture;
let payment_data = PaymentData {
flow: PhantomData,
payment_intent,
payment_attempt,
currency,
amount,
email: request.email.clone(),
mandate_id,
mandate_connector,
token,
token_data,
setup_mandate,
customer_acceptance,
address: PaymentAddress::new(
shipping_address.as_ref().map(From::from),
billing_address.as_ref().map(From::from),
payment_method_billing.as_ref().map(From::from),
business_profile.use_billing_as_payment_method_billing,
),
confirm: request.confirm,
payment_method_data: request
.payment_method_data
.as_ref()
.and_then(|pmd| pmd.payment_method_data.clone().map(Into::into)),
payment_method_token: None,
payment_method_info,
force_sync: None,
all_keys_required: None,
refunds: vec![],
disputes: vec![],
attempts: None,
sessions_token: vec![],
card_cvc: request.card_cvc.clone(),
creds_identifier,
pm_token: None,
connector_customer_id: None,
recurring_mandate_payment_data,
multiple_capture_data: None,
redirect_response: None,
surcharge_details,
frm_message: None,
payment_link_data: None,
incremental_authorization_details: None,
authorizations: vec![],
authentication: None,
recurring_details,
poll_config: None,
tax_data: None,
session_id: None,
service_details: None,
card_testing_guard_data: None,
vault_operation: None,
threeds_method_comp_ind: None,
whole_connector_response: None,
is_manual_retry_enabled: None,
is_l2_l3_enabled: business_profile.is_l2_l3_enabled,
external_authentication_data: None,
};
let get_trackers_response = operations::GetTrackerResponse {
operation: next_operation,
customer_details: Some(customer_details),
payment_data,
business_profile,
mandate_type,
};
Ok(get_trackers_response)
}
}
#[async_trait]
impl<F: Clone + Send + Sync> Domain<F, api::PaymentsRequest, PaymentData<F>> for PaymentUpdate {
#[instrument(skip_all)]
async fn populate_raw_customer_details<'a>(
&'a self,
state: &SessionState,
payment_data: &mut PaymentData<F>,
request: Option<&CustomerDetails>,
processor: &domain::Processor,
) -> CustomResult<(), errors::StorageError> {
helpers::populate_raw_customer_details(state, payment_data, request, processor).await
}
#[instrument(skip_all)]
async fn get_or_create_customer_details<'a>(
&'a self,
state: &SessionState,
payment_data: &mut PaymentData<F>,
request: Option<CustomerDetails>,
provider: &domain::Provider,
) -> CustomResult<(PaymentUpdateOperation<'a, F>, Option<domain::Customer>), errors::StorageError>
{
match provider.get_account().merchant_account_type {
common_enums::MerchantAccountType::Standard => {
helpers::create_customer_if_not_exist(
state,
Box::new(self),
payment_data,
request,
provider,
)
.await
}
common_enums::MerchantAccountType::Platform => {
let customer = helpers::get_customer_if_exists(
state,
request.as_ref().and_then(|r| r.customer_id.as_ref()),
payment_data.payment_intent.customer_id.as_ref(),
provider,
)
.await?
.map(|cust| {
payment_data
.payment_intent
.customer_id
.as_ref()
.is_some_and(|existing_id| existing_id != &cust.customer_id)
.then_some(errors::StorageError::ValueNotFound(
"Customer id mismatch between payment intent and request".to_string(),
))
.map_or(Ok(()), Err)?;
payment_data.email = payment_data
.email
.clone()
.or_else(|| cust.email.clone().map(Into::into));
Ok(cust)
})
.transpose()
.map_err(|e: errors::StorageError| report!(e))?;
Ok((Box::new(self), customer))
}
common_enums::MerchantAccountType::Connected => {
Err(errors::StorageError::ValueNotFound(
"Connected merchant cannot be a provider".to_string(),
)
.into())
}
}
}
async fn payments_dynamic_tax_calculation<'a>(
&'a self,
state: &SessionState,
payment_data: &mut PaymentData<F>,
_connector_call_type: &ConnectorCallType,
business_profile: &domain::Profile,
platform: &domain::Platform,
) -> CustomResult<(), errors::ApiErrorResponse> {
let is_tax_connector_enabled = business_profile.get_is_tax_connector_enabled();
let skip_external_tax_calculation = payment_data
.payment_intent
.skip_external_tax_calculation
.unwrap_or(false);
if is_tax_connector_enabled && !skip_external_tax_calculation {
let db = state.store.as_ref();
let merchant_connector_id = business_profile
.tax_connector_id
.as_ref()
.get_required_value("business_profile.tax_connector_id")?;
#[cfg(feature = "v1")]
let mca = db
.find_by_merchant_connector_account_merchant_id_merchant_connector_id(
&business_profile.merchant_id,
merchant_connector_id,
platform.get_processor().get_key_store(),
)
.await
.to_not_found_response(
errors::ApiErrorResponse::MerchantConnectorAccountNotFound {
id: merchant_connector_id.get_string_repr().to_string(),
},
)?;
#[cfg(feature = "v2")]
let mca = db
.find_merchant_connector_account_by_id(merchant_connector_id, key_store)
.await
.to_not_found_response(
errors::ApiErrorResponse::MerchantConnectorAccountNotFound {
id: merchant_connector_id.get_string_repr().to_string(),
},
)?;
let connector_data =
api::TaxCalculateConnectorData::get_connector_by_name(&mca.connector_name)?;
let router_data = core_utils::construct_payments_dynamic_tax_calculation_router_data(
state,
platform,
payment_data,
&mca,
)
.await?;
let connector_integration: services::BoxedPaymentConnectorIntegrationInterface<
api::CalculateTax,
types::PaymentsTaxCalculationData,
types::TaxCalculationResponseData,
> = connector_data.connector.get_connector_integration();
let response = services::execute_connector_processing_step(
state,
connector_integration,
&router_data,
payments::CallConnectorAction::Trigger,
None,
None,
)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Tax connector Response Failed")?;
let tax_response = response.response.map_err(|err| {
errors::ApiErrorResponse::ExternalConnectorError {
code: err.code,
message: err.message,
connector: connector_data.connector_name.clone().to_string(),
status_code: err.status_code,
reason: err.reason,
}
})?;
payment_data.payment_intent.tax_details = Some(diesel_models::TaxDetails {
default: Some(diesel_models::DefaultTax {
order_tax_amount: tax_response.order_tax_amount,
}),
payment_method_type: None,
});
Ok(())
} else {
Ok(())
}
}
#[instrument(skip_all)]
async fn make_pm_data<'a>(
&'a self,
state: &'a SessionState,
payment_data: &mut PaymentData<F>,
storage_scheme: storage_enums::MerchantStorageScheme,
merchant_key_store: &domain::MerchantKeyStore,
customer: &Option<domain::Customer>,
business_profile: &domain::Profile,
should_retry_with_pan: bool,
) -> RouterResult<(
PaymentUpdateOperation<'a, F>,
Option<domain::PaymentMethodData>,
Option<String>,
)> {
Box::pin(helpers::make_pm_data(
Box::new(self),
state,
payment_data,
merchant_key_store,
customer,
storage_scheme,
business_profile,
should_retry_with_pan,
))
.await
}
#[instrument(skip_all)]
async fn add_task_to_process_tracker<'a>(
&'a self,
_state: &'a SessionState,
_payment_attempt: &storage::PaymentAttempt,
_requeue: bool,
_schedule_time: Option<time::PrimitiveDateTime>,
) -> CustomResult<(), errors::ApiErrorResponse> {
Ok(())
}
async fn get_connector<'a>(
&'a self,
_platform: &domain::Platform,
state: &SessionState,
request: &api::PaymentsRequest,
_payment_intent: &storage::PaymentIntent,
) -> CustomResult<api::ConnectorChoice, errors::ApiErrorResponse> {
helpers::get_connector_default(state, request.routing.clone()).await
}
#[instrument(skip_all)]
async fn guard_payment_against_blocklist<'a>(
&'a self,
_state: &SessionState,
_platform: &domain::Platform,
_payment_data: &mut PaymentData<F>,
) -> CustomResult<bool, errors::ApiErrorResponse> {
Ok(false)
}
}
#[async_trait]
impl<F: Clone + Sync> UpdateTracker<F, PaymentData<F>, api::PaymentsRequest> for PaymentUpdate {
#[cfg(feature = "v2")]
#[instrument(skip_all)]
async fn update_trackers<'b>(
&'b self,
_state: &'b SessionState,
_req_state: ReqState,
_processor: &domain::Processor,
mut _payment_data: PaymentData<F>,
_customer: Option<domain::Customer>,
_frm_suggestion: Option<FrmSuggestion>,
_header_payload: hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<(PaymentUpdateOperation<'b, F>, PaymentData<F>)>
where
F: 'b + Send,
{
todo!()
}
#[cfg(feature = "v1")]
#[instrument(skip_all)]
async fn update_trackers<'b>(
&'b self,
state: &'b SessionState,
req_state: ReqState,
processor: &domain::Processor,
mut payment_data: PaymentData<F>,
customer: Option<domain::Customer>,
_frm_suggestion: Option<FrmSuggestion>,
_header_payload: hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<(PaymentUpdateOperation<'b, F>, PaymentData<F>)>
where
F: 'b + Send,
{
let storage_scheme = processor.get_account().storage_scheme;
let key_store = processor.get_key_store();
let is_payment_method_unavailable =
payment_data.payment_attempt.payment_method_id.is_none()
&& payment_data.payment_intent.status
== storage_enums::IntentStatus::RequiresPaymentMethod;
let payment_method = payment_data.payment_attempt.payment_method;
let get_attempt_status = || {
if is_payment_method_unavailable {
storage_enums::AttemptStatus::PaymentMethodAwaited
} else {
storage_enums::AttemptStatus::ConfirmationAwaited
}
};
let profile_id = payment_data
.payment_intent
.profile_id
.as_ref()
.get_required_value("profile_id")
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("'profile_id' not set in payment intent")?;
let additional_pm_data = payment_data
.payment_method_data
.as_ref()
.async_map(|payment_method_data| async {
helpers::get_additional_payment_data(
payment_method_data,
&*state.store,
profile_id,
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | true |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/payments/operations/payment_update_metadata.rs | crates/router/src/core/payments/operations/payment_update_metadata.rs | use std::marker::PhantomData;
use api_models::enums::FrmSuggestion;
use async_trait::async_trait;
use error_stack::ResultExt;
use masking::ExposeInterface;
use router_derive::PaymentOperation;
use router_env::{instrument, tracing};
use super::{BoxedOperation, Domain, GetTracker, Operation, UpdateTracker, ValidateRequest};
use crate::{
core::{
errors::{self, RouterResult, StorageErrorExt},
payments::{self, helpers, operations, PaymentData},
},
routes::{app::ReqState, SessionState},
services,
types::{
api::{self, PaymentIdTypeExt},
domain,
storage::{self, enums as storage_enums},
},
utils::OptionExt,
};
#[derive(Debug, Clone, Copy, PaymentOperation)]
#[operation(operations = "all", flow = "update_metadata")]
pub struct PaymentUpdateMetadata;
type PaymentUpdateMetadataOperation<'b, F> =
BoxedOperation<'b, F, api::PaymentsUpdateMetadataRequest, PaymentData<F>>;
#[async_trait]
impl<F: Send + Clone + Sync> GetTracker<F, PaymentData<F>, api::PaymentsUpdateMetadataRequest>
for PaymentUpdateMetadata
{
#[instrument(skip_all)]
async fn get_trackers<'a>(
&'a self,
state: &'a SessionState,
payment_id: &api::PaymentIdType,
request: &api::PaymentsUpdateMetadataRequest,
platform: &domain::Platform,
_auth_flow: services::AuthFlow,
_header_payload: &hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<
operations::GetTrackerResponse<'a, F, api::PaymentsUpdateMetadataRequest, PaymentData<F>>,
> {
let payment_id = payment_id
.get_payment_intent_id()
.change_context(errors::ApiErrorResponse::PaymentNotFound)?;
let db = &*state.store;
let merchant_id = platform.get_processor().get_account().get_id();
let storage_scheme = platform.get_processor().get_account().storage_scheme;
let mut payment_intent = db
.find_payment_intent_by_payment_id_merchant_id(
&payment_id,
merchant_id,
platform.get_processor().get_key_store(),
storage_scheme,
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
helpers::validate_payment_status_against_allowed_statuses(
payment_intent.status,
&[
storage_enums::IntentStatus::Succeeded,
storage_enums::IntentStatus::Failed,
storage_enums::IntentStatus::PartiallyCaptured,
storage_enums::IntentStatus::PartiallyCapturedAndCapturable,
storage_enums::IntentStatus::RequiresCapture,
],
"update_metadata",
)?;
let payment_attempt = db
.find_payment_attempt_by_payment_id_merchant_id_attempt_id(
&payment_intent.payment_id,
merchant_id,
payment_intent.active_attempt.get_id().as_str(),
storage_scheme,
platform.get_processor().get_key_store(),
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
let currency = payment_intent.currency.get_required_value("currency")?;
let amount = payment_attempt.get_total_amount().into();
let profile_id = payment_intent
.profile_id
.as_ref()
.get_required_value("profile_id")
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("'profile_id' not set in payment intent")?;
let business_profile = db
.find_business_profile_by_profile_id(
platform.get_processor().get_key_store(),
profile_id,
)
.await
.to_not_found_response(errors::ApiErrorResponse::ProfileNotFound {
id: profile_id.get_string_repr().to_owned(),
})?;
let merged_metadata = payment_intent
.merge_metadata(request.metadata.clone().expose())
.change_context(errors::ApiErrorResponse::InvalidRequestData {
message: "Metadata should be an object and contain at least 1 key".to_owned(),
})?;
payment_intent.metadata = Some(merged_metadata);
let payment_data = PaymentData {
flow: PhantomData,
payment_intent,
payment_attempt,
currency,
amount,
email: None,
mandate_id: None,
mandate_connector: None,
customer_acceptance: None,
token: None,
token_data: None,
setup_mandate: None,
address: payments::PaymentAddress::new(None, None, None, None),
confirm: None,
payment_method_data: None,
payment_method_token: None,
payment_method_info: None,
force_sync: None,
all_keys_required: None,
refunds: vec![],
disputes: vec![],
attempts: None,
sessions_token: vec![],
card_cvc: None,
creds_identifier: None,
pm_token: None,
connector_customer_id: None,
recurring_mandate_payment_data: None,
multiple_capture_data: None,
redirect_response: None,
surcharge_details: None,
frm_message: None,
payment_link_data: None,
incremental_authorization_details: None,
authorizations: vec![],
authentication: None,
recurring_details: None,
poll_config: None,
tax_data: None,
session_id: None,
service_details: None,
card_testing_guard_data: None,
vault_operation: None,
threeds_method_comp_ind: None,
whole_connector_response: None,
is_manual_retry_enabled: None,
is_l2_l3_enabled: false,
external_authentication_data: None,
};
let get_trackers_response = operations::GetTrackerResponse {
operation: Box::new(self),
customer_details: None,
payment_data,
business_profile,
mandate_type: None,
};
Ok(get_trackers_response)
}
}
#[async_trait]
impl<F: Clone + Send + Sync> Domain<F, api::PaymentsUpdateMetadataRequest, PaymentData<F>>
for PaymentUpdateMetadata
{
#[instrument(skip_all)]
async fn populate_raw_customer_details<'a>(
&'a self,
_state: &SessionState,
_payment_data: &mut PaymentData<F>,
_request: Option<&payments::CustomerDetails>,
_processor: &domain::Processor,
) -> errors::CustomResult<(), errors::StorageError> {
Ok(())
}
#[instrument(skip_all)]
async fn get_or_create_customer_details<'a>(
&'a self,
_state: &SessionState,
_payment_data: &mut PaymentData<F>,
_request: Option<payments::CustomerDetails>,
_provider: &domain::Provider,
) -> errors::CustomResult<
(
PaymentUpdateMetadataOperation<'a, F>,
Option<domain::Customer>,
),
errors::StorageError,
> {
Ok((Box::new(self), None))
}
#[instrument(skip_all)]
async fn make_pm_data<'a>(
&'a self,
_state: &'a SessionState,
_payment_data: &mut PaymentData<F>,
_storage_scheme: storage_enums::MerchantStorageScheme,
_merchant_key_store: &domain::MerchantKeyStore,
_customer: &Option<domain::Customer>,
_business_profile: &domain::Profile,
_should_retry_with_pan: bool,
) -> RouterResult<(
PaymentUpdateMetadataOperation<'a, F>,
Option<domain::PaymentMethodData>,
Option<String>,
)> {
Ok((Box::new(self), None, None))
}
async fn get_connector<'a>(
&'a self,
_platform: &domain::Platform,
state: &SessionState,
_request: &api::PaymentsUpdateMetadataRequest,
_payment_intent: &storage::PaymentIntent,
) -> errors::CustomResult<api::ConnectorChoice, errors::ApiErrorResponse> {
helpers::get_connector_default(state, None).await
}
#[instrument(skip_all)]
async fn guard_payment_against_blocklist<'a>(
&'a self,
_state: &SessionState,
_platform: &domain::Platform,
_payment_data: &mut PaymentData<F>,
) -> errors::CustomResult<bool, errors::ApiErrorResponse> {
Ok(false)
}
}
#[async_trait]
impl<F: Clone + Sync> UpdateTracker<F, PaymentData<F>, api::PaymentsUpdateMetadataRequest>
for PaymentUpdateMetadata
{
#[instrument(skip_all)]
async fn update_trackers<'b>(
&'b self,
_state: &'b SessionState,
_req_state: ReqState,
_processor: &domain::Processor,
payment_data: PaymentData<F>,
_customer: Option<domain::Customer>,
_frm_suggestion: Option<FrmSuggestion>,
_header_payload: hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<(PaymentUpdateMetadataOperation<'b, F>, PaymentData<F>)>
where
F: 'b + Send,
{
Ok((Box::new(self), payment_data))
}
}
impl<F: Send + Clone + Sync> ValidateRequest<F, api::PaymentsUpdateMetadataRequest, PaymentData<F>>
for PaymentUpdateMetadata
{
#[instrument(skip_all)]
fn validate_request<'a, 'b>(
&'b self,
request: &api::PaymentsUpdateMetadataRequest,
processor: &'a domain::Processor,
) -> RouterResult<(
PaymentUpdateMetadataOperation<'b, F>,
operations::ValidateResult,
)> {
//payment id is already generated and should be sent in the request
let given_payment_id = request.payment_id.clone();
Ok((
Box::new(self),
operations::ValidateResult {
merchant_id: processor.get_account().get_id().to_owned(),
payment_id: api::PaymentIdType::PaymentIntentId(given_payment_id),
storage_scheme: processor.get_account().storage_scheme,
requeue: false,
},
))
}
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/payments/operations/payments_incremental_authorization.rs | crates/router/src/core/payments/operations/payments_incremental_authorization.rs | use std::marker::PhantomData;
use api_models::{enums::FrmSuggestion, payments::PaymentsIncrementalAuthorizationRequest};
use async_trait::async_trait;
use common_utils::errors::CustomResult;
use diesel_models::authorization::AuthorizationNew;
use error_stack::{report, ResultExt};
use router_env::{instrument, tracing};
use super::{BoxedOperation, Domain, GetTracker, Operation, UpdateTracker, ValidateRequest};
use crate::{
core::{
errors::{self, RouterResult, StorageErrorExt},
payments::{
self, helpers, operations, CustomerDetails, IncrementalAuthorizationDetails,
PaymentAddress,
},
},
routes::{app::ReqState, SessionState},
services,
types::{
api::{self, PaymentIdTypeExt},
domain,
storage::{self, enums},
},
utils::OptionExt,
};
#[derive(Debug, Clone, Copy, router_derive::PaymentOperation)]
#[operation(operations = "all", flow = "incremental_authorization")]
pub struct PaymentIncrementalAuthorization;
type PaymentIncrementalAuthorizationOperation<'b, F> =
BoxedOperation<'b, F, PaymentsIncrementalAuthorizationRequest, payments::PaymentData<F>>;
#[async_trait]
impl<F: Send + Clone + Sync>
GetTracker<F, payments::PaymentData<F>, PaymentsIncrementalAuthorizationRequest>
for PaymentIncrementalAuthorization
{
#[instrument(skip_all)]
async fn get_trackers<'a>(
&'a self,
state: &'a SessionState,
payment_id: &api::PaymentIdType,
request: &PaymentsIncrementalAuthorizationRequest,
platform: &domain::Platform,
_auth_flow: services::AuthFlow,
_header_payload: &hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<
operations::GetTrackerResponse<
'a,
F,
PaymentsIncrementalAuthorizationRequest,
payments::PaymentData<F>,
>,
> {
let db = &*state.store;
let merchant_id = platform.get_processor().get_account().get_id();
let storage_scheme = platform.get_processor().get_account().storage_scheme;
let payment_id = payment_id
.get_payment_intent_id()
.change_context(errors::ApiErrorResponse::PaymentNotFound)?;
let payment_intent = db
.find_payment_intent_by_payment_id_merchant_id(
&payment_id,
merchant_id,
platform.get_processor().get_key_store(),
storage_scheme,
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
helpers::validate_payment_status_against_allowed_statuses(
payment_intent.status,
&[enums::IntentStatus::RequiresCapture],
"increment authorization",
)?;
if payment_intent.incremental_authorization_allowed != Some(true) {
Err(errors::ApiErrorResponse::PreconditionFailed {
message:
"You cannot increment authorization this payment because it is not allowed for incremental_authorization".to_owned(),
})?
}
let attempt_id = payment_intent.active_attempt.get_id().clone();
let payment_attempt = db
.find_payment_attempt_by_payment_id_merchant_id_attempt_id(
&payment_intent.payment_id,
merchant_id,
attempt_id.clone().as_str(),
storage_scheme,
platform.get_processor().get_key_store(),
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
// Incremental authorization should be performed on an amount greater than the original authorized amount (in this case, greater than the net_amount which is sent for authorization)
// request.amount is the total amount that should be authorized in incremental authorization which should be greater than the original authorized amount
if payment_attempt.get_total_amount() >= request.amount {
Err(errors::ApiErrorResponse::PreconditionFailed {
message: "Amount should be greater than original authorized amount".to_owned(),
})?
}
let currency = payment_attempt.currency.get_required_value("currency")?;
let amount = payment_attempt.get_total_amount();
let profile_id = payment_intent
.profile_id
.as_ref()
.get_required_value("profile_id")
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("'profile_id' not set in payment intent")?;
let business_profile = state
.store
.find_business_profile_by_profile_id(
platform.get_processor().get_key_store(),
profile_id,
)
.await
.to_not_found_response(errors::ApiErrorResponse::ProfileNotFound {
id: profile_id.get_string_repr().to_owned(),
})?;
let payment_data = payments::PaymentData {
flow: PhantomData,
payment_intent,
payment_attempt,
currency,
amount: amount.into(),
email: None,
mandate_id: None,
mandate_connector: None,
setup_mandate: None,
customer_acceptance: None,
token: None,
token_data: None,
address: PaymentAddress::new(None, None, None, None),
confirm: None,
payment_method_data: None,
payment_method_token: None,
payment_method_info: None,
force_sync: None,
all_keys_required: None,
refunds: vec![],
disputes: vec![],
attempts: None,
sessions_token: vec![],
card_cvc: None,
creds_identifier: None,
pm_token: None,
connector_customer_id: None,
recurring_mandate_payment_data: None,
multiple_capture_data: None,
redirect_response: None,
surcharge_details: None,
frm_message: None,
payment_link_data: None,
incremental_authorization_details: Some(IncrementalAuthorizationDetails {
additional_amount: request.amount - amount,
total_amount: request.amount,
reason: request.reason.clone(),
authorization_id: None,
}),
authorizations: vec![],
authentication: None,
recurring_details: None,
poll_config: None,
tax_data: None,
session_id: None,
service_details: None,
card_testing_guard_data: None,
vault_operation: None,
threeds_method_comp_ind: None,
whole_connector_response: None,
is_manual_retry_enabled: None,
is_l2_l3_enabled: false,
external_authentication_data: None,
};
let get_trackers_response = operations::GetTrackerResponse {
operation: Box::new(self),
customer_details: None,
payment_data,
business_profile,
mandate_type: None,
};
Ok(get_trackers_response)
}
}
#[async_trait]
impl<F: Clone + Sync>
UpdateTracker<F, payments::PaymentData<F>, PaymentsIncrementalAuthorizationRequest>
for PaymentIncrementalAuthorization
{
#[instrument(skip_all)]
async fn update_trackers<'b>(
&'b self,
state: &'b SessionState,
_req_state: ReqState,
processor: &domain::Processor,
mut payment_data: payments::PaymentData<F>,
_customer: Option<domain::Customer>,
_frm_suggestion: Option<FrmSuggestion>,
_header_payload: hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<(
PaymentIncrementalAuthorizationOperation<'b, F>,
payments::PaymentData<F>,
)>
where
F: 'b + Send,
{
let storage_scheme = processor.get_account().storage_scheme;
let key_store = processor.get_key_store();
let new_authorization_count = payment_data
.payment_intent
.authorization_count
.map(|count| count + 1)
.unwrap_or(1);
// Create new authorization record
let authorization_new = AuthorizationNew {
authorization_id: format!(
"{}_{}",
common_utils::generate_id_with_default_len("auth"),
new_authorization_count
),
merchant_id: payment_data.payment_intent.merchant_id.clone(),
payment_id: payment_data.payment_intent.payment_id.clone(),
amount: payment_data
.incremental_authorization_details
.clone()
.map(|details| details.total_amount)
.ok_or(
report!(errors::ApiErrorResponse::InternalServerError).attach_printable(
"missing incremental_authorization_details in payment_data",
),
)?,
status: common_enums::AuthorizationStatus::Processing,
error_code: None,
error_message: None,
connector_authorization_id: None,
previously_authorized_amount: payment_data.payment_attempt.get_total_amount(),
};
let authorization = state
.store
.insert_authorization(authorization_new.clone())
.await
.to_duplicate_response(errors::ApiErrorResponse::GenericDuplicateError {
message: format!(
"Authorization with authorization_id {} already exists",
authorization_new.authorization_id
),
})
.attach_printable("failed while inserting new authorization")?;
// Update authorization_count in payment_intent
payment_data.payment_intent = state
.store
.update_payment_intent(
payment_data.payment_intent.clone(),
storage::PaymentIntentUpdate::AuthorizationCountUpdate {
authorization_count: new_authorization_count,
},
key_store,
storage_scheme,
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)
.attach_printable("Failed to update authorization_count in Payment Intent")?;
match &payment_data.incremental_authorization_details {
Some(details) => {
payment_data.incremental_authorization_details =
Some(IncrementalAuthorizationDetails {
authorization_id: Some(authorization.authorization_id),
..details.clone()
});
}
None => Err(errors::ApiErrorResponse::InternalServerError)
.attach_printable("missing incremental_authorization_details in payment_data")?,
}
Ok((Box::new(self), payment_data))
}
}
impl<F: Send + Clone + Sync>
ValidateRequest<F, PaymentsIncrementalAuthorizationRequest, payments::PaymentData<F>>
for PaymentIncrementalAuthorization
{
#[instrument(skip_all)]
fn validate_request<'a, 'b>(
&'b self,
request: &PaymentsIncrementalAuthorizationRequest,
processor: &'a domain::Processor,
) -> RouterResult<(
PaymentIncrementalAuthorizationOperation<'b, F>,
operations::ValidateResult,
)> {
Ok((
Box::new(self),
operations::ValidateResult {
merchant_id: processor.get_account().get_id().to_owned(),
payment_id: api::PaymentIdType::PaymentIntentId(request.payment_id.to_owned()),
storage_scheme: processor.get_account().storage_scheme,
requeue: false,
},
))
}
}
#[async_trait]
impl<F: Clone + Send + Sync>
Domain<F, PaymentsIncrementalAuthorizationRequest, payments::PaymentData<F>>
for PaymentIncrementalAuthorization
{
#[instrument(skip_all)]
async fn populate_raw_customer_details<'a>(
&'a self,
_state: &SessionState,
_payment_data: &mut payments::PaymentData<F>,
_request: Option<&CustomerDetails>,
_processor: &domain::Processor,
) -> CustomResult<(), errors::StorageError> {
Ok(())
}
#[instrument(skip_all)]
async fn get_or_create_customer_details<'a>(
&'a self,
_state: &SessionState,
_payment_data: &mut payments::PaymentData<F>,
_request: Option<CustomerDetails>,
_provider: &domain::Provider,
) -> CustomResult<
(
BoxedOperation<
'a,
F,
PaymentsIncrementalAuthorizationRequest,
payments::PaymentData<F>,
>,
Option<domain::Customer>,
),
errors::StorageError,
> {
Ok((Box::new(self), None))
}
#[instrument(skip_all)]
async fn make_pm_data<'a>(
&'a self,
_state: &'a SessionState,
_payment_data: &mut payments::PaymentData<F>,
_storage_scheme: enums::MerchantStorageScheme,
_merchant_key_store: &domain::MerchantKeyStore,
_customer: &Option<domain::Customer>,
_business_profile: &domain::Profile,
_should_retry_with_pan: bool,
) -> RouterResult<(
PaymentIncrementalAuthorizationOperation<'a, F>,
Option<domain::PaymentMethodData>,
Option<String>,
)> {
Ok((Box::new(self), None, None))
}
async fn get_connector<'a>(
&'a self,
_platform: &domain::Platform,
state: &SessionState,
_request: &PaymentsIncrementalAuthorizationRequest,
_payment_intent: &storage::PaymentIntent,
) -> CustomResult<api::ConnectorChoice, errors::ApiErrorResponse> {
helpers::get_connector_default(state, None).await
}
#[instrument(skip_all)]
async fn guard_payment_against_blocklist<'a>(
&'a self,
_state: &SessionState,
_platform: &domain::Platform,
_payment_data: &mut payments::PaymentData<F>,
) -> CustomResult<bool, errors::ApiErrorResponse> {
Ok(false)
}
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/payments/operations/payment_update_intent.rs | crates/router/src/core/payments/operations/payment_update_intent.rs | use std::marker::PhantomData;
use api_models::{
enums::{FrmSuggestion, UpdateActiveAttempt},
payments::PaymentsUpdateIntentRequest,
};
use async_trait::async_trait;
use common_utils::{
errors::CustomResult,
ext_traits::{Encode, ValueExt},
types::keymanager::ToEncryptable,
};
use diesel_models::types::FeatureMetadata;
use error_stack::ResultExt;
use hyperswitch_domain_models::{
payments::payment_intent::{PaymentIntentUpdate, PaymentIntentUpdateFields},
ApiModelToDieselModelConvertor,
};
use masking::PeekInterface;
use router_env::{instrument, tracing};
use super::{BoxedOperation, Domain, GetTracker, Operation, UpdateTracker, ValidateRequest};
use crate::{
core::{
errors::{self, RouterResult},
payments::{
self, helpers,
operations::{self, ValidateStatusForOperation},
},
},
db::errors::StorageErrorExt,
routes::{app::ReqState, SessionState},
types::{
api,
domain::{self, types as domain_types},
storage::{self, enums},
},
};
#[derive(Debug, Clone, Copy)]
pub struct PaymentUpdateIntent;
impl ValidateStatusForOperation for PaymentUpdateIntent {
/// Validate if the current operation can be performed on the current status of the payment intent
fn validate_status_for_operation(
&self,
intent_status: common_enums::IntentStatus,
) -> Result<(), errors::ApiErrorResponse> {
match intent_status {
// if the status is `Failed`` we would want to Update few intent fields to perform a Revenue Recovery retry
common_enums::IntentStatus::RequiresPaymentMethod
| common_enums::IntentStatus::Failed
| common_enums::IntentStatus::Conflicted => Ok(()),
common_enums::IntentStatus::Succeeded
| common_enums::IntentStatus::Cancelled
| common_enums::IntentStatus::CancelledPostCapture
| common_enums::IntentStatus::Processing
| common_enums::IntentStatus::PartiallyCapturedAndProcessing
| common_enums::IntentStatus::RequiresCustomerAction
| common_enums::IntentStatus::RequiresMerchantAction
| common_enums::IntentStatus::RequiresCapture
| common_enums::IntentStatus::PartiallyAuthorizedAndRequiresCapture
| common_enums::IntentStatus::PartiallyCaptured
| common_enums::IntentStatus::PartiallyCapturedAndProcessing
| common_enums::IntentStatus::RequiresConfirmation
| common_enums::IntentStatus::PartiallyCapturedAndCapturable
| common_enums::IntentStatus::Expired => {
Err(errors::ApiErrorResponse::PaymentUnexpectedState {
current_flow: format!("{self:?}"),
field_name: "status".to_string(),
current_value: intent_status.to_string(),
states: ["requires_payment_method".to_string()].join(", "),
})
}
}
}
}
impl<F: Send + Clone> Operation<F, PaymentsUpdateIntentRequest> for &PaymentUpdateIntent {
type Data = payments::PaymentIntentData<F>;
fn to_validate_request(
&self,
) -> RouterResult<
&(dyn ValidateRequest<F, PaymentsUpdateIntentRequest, Self::Data> + Send + Sync),
> {
Ok(*self)
}
fn to_get_tracker(
&self,
) -> RouterResult<&(dyn GetTracker<F, Self::Data, PaymentsUpdateIntentRequest> + Send + Sync)>
{
Ok(*self)
}
fn to_domain(&self) -> RouterResult<&(dyn Domain<F, PaymentsUpdateIntentRequest, Self::Data>)> {
Ok(*self)
}
fn to_update_tracker(
&self,
) -> RouterResult<&(dyn UpdateTracker<F, Self::Data, PaymentsUpdateIntentRequest> + Send + Sync)>
{
Ok(*self)
}
}
impl<F: Send + Clone> Operation<F, PaymentsUpdateIntentRequest> for PaymentUpdateIntent {
type Data = payments::PaymentIntentData<F>;
fn to_validate_request(
&self,
) -> RouterResult<
&(dyn ValidateRequest<F, PaymentsUpdateIntentRequest, Self::Data> + Send + Sync),
> {
Ok(self)
}
fn to_get_tracker(
&self,
) -> RouterResult<&(dyn GetTracker<F, Self::Data, PaymentsUpdateIntentRequest> + Send + Sync)>
{
Ok(self)
}
fn to_domain(&self) -> RouterResult<&dyn Domain<F, PaymentsUpdateIntentRequest, Self::Data>> {
Ok(self)
}
fn to_update_tracker(
&self,
) -> RouterResult<&(dyn UpdateTracker<F, Self::Data, PaymentsUpdateIntentRequest> + Send + Sync)>
{
Ok(self)
}
}
type PaymentsUpdateIntentOperation<'b, F> =
BoxedOperation<'b, F, PaymentsUpdateIntentRequest, payments::PaymentIntentData<F>>;
#[async_trait]
impl<F: Send + Clone> GetTracker<F, payments::PaymentIntentData<F>, PaymentsUpdateIntentRequest>
for PaymentUpdateIntent
{
#[instrument(skip_all)]
async fn get_trackers<'a>(
&'a self,
state: &'a SessionState,
payment_id: &common_utils::id_type::GlobalPaymentId,
request: &PaymentsUpdateIntentRequest,
platform: &domain::Platform,
profile: &domain::Profile,
_header_payload: &hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<operations::GetTrackerResponse<payments::PaymentIntentData<F>>> {
let db = &*state.store;
if let Some(routing_algorithm_id) = request.routing_algorithm_id.as_ref() {
helpers::validate_routing_id_with_profile_id(
db,
routing_algorithm_id,
profile.get_id(),
)
.await?;
}
let key_manager_state = &state.into();
let storage_scheme = platform.get_processor().get_account().storage_scheme;
let storage_scheme = platform.get_processor().get_account().storage_scheme;
let payment_intent = db
.find_payment_intent_by_id(
payment_id,
platform.get_processor().get_key_store(),
storage_scheme,
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
self.validate_status_for_operation(payment_intent.status)?;
let PaymentsUpdateIntentRequest {
amount_details,
routing_algorithm_id,
capture_method,
authentication_type,
billing,
shipping,
customer_present,
description,
return_url,
setup_future_usage,
apply_mit_exemption,
statement_descriptor,
order_details,
allowed_payment_method_types,
metadata,
connector_metadata,
feature_metadata,
payment_link_config,
request_incremental_authorization,
session_expiry,
frm_metadata,
request_external_three_ds_authentication,
set_active_attempt_id,
enable_partial_authorization,
} = request.clone();
let batch_encrypted_data = domain_types::crypto_operation(
key_manager_state,
common_utils::type_name!(hyperswitch_domain_models::payments::PaymentIntent),
domain_types::CryptoOperation::BatchEncrypt(
hyperswitch_domain_models::payments::FromRequestEncryptablePaymentIntent::to_encryptable(
hyperswitch_domain_models::payments::FromRequestEncryptablePaymentIntent {
shipping_address: shipping.map(|address| address.encode_to_value()).transpose().change_context(errors::ApiErrorResponse::InternalServerError).attach_printable("Failed to encode shipping address")?.map(masking::Secret::new),
billing_address: billing.map(|address| address.encode_to_value()).transpose().change_context(errors::ApiErrorResponse::InternalServerError).attach_printable("Failed to encode billing address")?.map(masking::Secret::new),
customer_details: None,
},
),
),
common_utils::types::keymanager::Identifier::Merchant(platform.get_processor().get_account().get_id().to_owned()),
platform.get_processor().get_key_store().key.peek(),
)
.await
.and_then(|val| val.try_into_batchoperation())
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed while encrypting payment intent details".to_string())?;
let decrypted_payment_intent =
hyperswitch_domain_models::payments::FromRequestEncryptablePaymentIntent::from_encryptable(batch_encrypted_data)
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed while encrypting payment intent details")?;
let order_details = order_details.clone().map(|order_details| {
order_details
.into_iter()
.map(|order_detail| {
masking::Secret::new(
diesel_models::types::OrderDetailsWithAmount::convert_from(order_detail),
)
})
.collect()
});
let session_expiry = session_expiry.map(|expiry| {
payment_intent
.created_at
.saturating_add(time::Duration::seconds(i64::from(expiry)))
});
let updated_amount_details = match amount_details {
Some(details) => payment_intent.amount_details.update_from_request(&details),
None => payment_intent.amount_details,
};
let active_attempt_id = set_active_attempt_id
.map(|active_attempt_req| match active_attempt_req {
UpdateActiveAttempt::Set(global_attempt_id) => Some(global_attempt_id),
UpdateActiveAttempt::Unset => None,
})
.unwrap_or(payment_intent.active_attempt_id);
let payment_intent = hyperswitch_domain_models::payments::PaymentIntent {
amount_details: updated_amount_details,
description: description.or(payment_intent.description),
return_url: return_url.or(payment_intent.return_url),
metadata: metadata.or(payment_intent.metadata),
statement_descriptor: statement_descriptor.or(payment_intent.statement_descriptor),
modified_at: common_utils::date_time::now(),
order_details,
connector_metadata: connector_metadata.or(payment_intent.connector_metadata),
feature_metadata: (feature_metadata
.map(FeatureMetadata::convert_from)
.or(payment_intent.feature_metadata)),
updated_by: storage_scheme.to_string(),
request_incremental_authorization: request_incremental_authorization
.unwrap_or(payment_intent.request_incremental_authorization),
session_expiry: session_expiry.unwrap_or(payment_intent.session_expiry),
request_external_three_ds_authentication: request_external_three_ds_authentication
.unwrap_or(payment_intent.request_external_three_ds_authentication),
frm_metadata: frm_metadata.or(payment_intent.frm_metadata),
billing_address: decrypted_payment_intent
.billing_address
.as_ref()
.map(|data| {
data.clone()
.deserialize_inner_value(|value| value.parse_value("Address"))
})
.transpose()
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Unable to decode billing address")?,
shipping_address: decrypted_payment_intent
.shipping_address
.as_ref()
.map(|data| {
data.clone()
.deserialize_inner_value(|value| value.parse_value("Address"))
})
.transpose()
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Unable to decode shipping address")?,
capture_method: capture_method.unwrap_or(payment_intent.capture_method),
authentication_type: authentication_type.or(payment_intent.authentication_type),
payment_link_config: payment_link_config
.map(ApiModelToDieselModelConvertor::convert_from)
.or(payment_intent.payment_link_config),
apply_mit_exemption: apply_mit_exemption.unwrap_or(payment_intent.apply_mit_exemption),
customer_present: customer_present.unwrap_or(payment_intent.customer_present),
routing_algorithm_id: routing_algorithm_id.or(payment_intent.routing_algorithm_id),
allowed_payment_method_types: allowed_payment_method_types
.or(payment_intent.allowed_payment_method_types),
active_attempt_id,
enable_partial_authorization: enable_partial_authorization
.unwrap_or(payment_intent.enable_partial_authorization),
setup_future_usage: setup_future_usage.unwrap_or(payment_intent.setup_future_usage),
..payment_intent
};
let payment_data = payments::PaymentIntentData {
flow: PhantomData,
payment_intent,
client_secret: None,
sessions_token: vec![],
vault_session_details: None,
connector_customer_id: None,
};
let get_trackers_response = operations::GetTrackerResponse { payment_data };
Ok(get_trackers_response)
}
}
#[async_trait]
impl<F: Clone> UpdateTracker<F, payments::PaymentIntentData<F>, PaymentsUpdateIntentRequest>
for PaymentUpdateIntent
{
#[instrument(skip_all)]
async fn update_trackers<'b>(
&'b self,
state: &'b SessionState,
_req_state: ReqState,
processor: &domain::Processor,
mut payment_data: payments::PaymentIntentData<F>,
_customer: Option<domain::Customer>,
_frm_suggestion: Option<FrmSuggestion>,
_header_payload: hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<(
PaymentsUpdateIntentOperation<'b, F>,
payments::PaymentIntentData<F>,
)>
where
F: 'b + Send,
{
let db = &*state.store;
let storage_scheme = processor.get_account().storage_scheme;
let key_store = processor.get_key_store();
let intent = payment_data.payment_intent.clone();
let payment_intent_update =
PaymentIntentUpdate::UpdateIntent(Box::new(PaymentIntentUpdateFields {
amount: Some(intent.amount_details.order_amount),
currency: Some(intent.amount_details.currency),
shipping_cost: intent.amount_details.shipping_cost,
skip_external_tax_calculation: Some(
intent.amount_details.skip_external_tax_calculation,
),
skip_surcharge_calculation: Some(intent.amount_details.skip_surcharge_calculation),
surcharge_amount: intent.amount_details.surcharge_amount,
tax_on_surcharge: intent.amount_details.tax_on_surcharge,
routing_algorithm_id: intent.routing_algorithm_id,
capture_method: Some(intent.capture_method),
authentication_type: intent.authentication_type,
billing_address: intent.billing_address,
shipping_address: intent.shipping_address,
customer_present: Some(intent.customer_present),
description: intent.description,
return_url: intent.return_url,
setup_future_usage: Some(intent.setup_future_usage),
apply_mit_exemption: Some(intent.apply_mit_exemption),
statement_descriptor: intent.statement_descriptor,
order_details: intent.order_details,
allowed_payment_method_types: intent.allowed_payment_method_types,
metadata: intent.metadata,
connector_metadata: intent
.connector_metadata
.map(|cm| cm.encode_to_value())
.transpose()
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed to serialize connector_metadata")?
.map(masking::Secret::new),
feature_metadata: intent.feature_metadata,
payment_link_config: intent.payment_link_config,
request_incremental_authorization: Some(intent.request_incremental_authorization),
session_expiry: Some(intent.session_expiry),
frm_metadata: intent.frm_metadata,
request_external_three_ds_authentication: Some(
intent.request_external_three_ds_authentication,
),
updated_by: intent.updated_by,
tax_details: intent.amount_details.tax_details,
active_attempt_id: Some(intent.active_attempt_id),
force_3ds_challenge: intent.force_3ds_challenge,
is_iframe_redirection_enabled: intent.is_iframe_redirection_enabled,
enable_partial_authorization: Some(intent.enable_partial_authorization),
active_attempts_group_id: intent.active_attempts_group_id,
active_attempt_id_type: Some(intent.active_attempt_id_type),
}));
let new_payment_intent = db
.update_payment_intent(
payment_data.payment_intent,
payment_intent_update,
key_store,
storage_scheme,
)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Could not update Intent")?;
payment_data.payment_intent = new_payment_intent;
Ok((Box::new(self), payment_data))
}
}
impl<F: Send + Clone>
ValidateRequest<F, PaymentsUpdateIntentRequest, payments::PaymentIntentData<F>>
for PaymentUpdateIntent
{
#[instrument(skip_all)]
fn validate_request<'a, 'b>(
&'b self,
_request: &PaymentsUpdateIntentRequest,
platform: &'a domain::Platform,
) -> RouterResult<operations::ValidateResult> {
Ok(operations::ValidateResult {
merchant_id: platform.get_processor().get_account().get_id().to_owned(),
storage_scheme: platform.get_processor().get_account().storage_scheme,
requeue: false,
})
}
}
#[async_trait]
impl<F: Clone + Send> Domain<F, PaymentsUpdateIntentRequest, payments::PaymentIntentData<F>>
for PaymentUpdateIntent
{
#[instrument(skip_all)]
async fn get_customer_details<'a>(
&'a self,
_state: &SessionState,
_payment_data: &mut payments::PaymentIntentData<F>,
_merchant_key_store: &domain::MerchantKeyStore,
_storage_scheme: enums::MerchantStorageScheme,
) -> CustomResult<
(
BoxedOperation<'a, F, PaymentsUpdateIntentRequest, payments::PaymentIntentData<F>>,
Option<domain::Customer>,
),
errors::StorageError,
> {
Ok((Box::new(self), None))
}
#[instrument(skip_all)]
async fn make_pm_data<'a>(
&'a self,
_state: &'a SessionState,
_payment_data: &mut payments::PaymentIntentData<F>,
_storage_scheme: enums::MerchantStorageScheme,
_merchant_key_store: &domain::MerchantKeyStore,
_customer: &Option<domain::Customer>,
_business_profile: &domain::Profile,
_should_retry_with_pan: bool,
) -> RouterResult<(
PaymentsUpdateIntentOperation<'a, F>,
Option<domain::PaymentMethodData>,
Option<String>,
)> {
Ok((Box::new(self), None, None))
}
#[instrument(skip_all)]
async fn perform_routing<'a>(
&'a self,
_platform: &domain::Platform,
_business_profile: &domain::Profile,
_state: &SessionState,
_payment_data: &mut payments::PaymentIntentData<F>,
) -> CustomResult<api::ConnectorCallType, errors::ApiErrorResponse> {
Ok(api::ConnectorCallType::Skip)
}
#[instrument(skip_all)]
async fn guard_payment_against_blocklist<'a>(
&'a self,
_state: &SessionState,
_platform: &domain::Platform,
_payment_data: &mut payments::PaymentIntentData<F>,
) -> CustomResult<bool, errors::ApiErrorResponse> {
Ok(false)
}
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/payments/operations/payments_extend_authorization.rs | crates/router/src/core/payments/operations/payments_extend_authorization.rs | use std::marker::PhantomData;
use api_models::enums::FrmSuggestion;
use async_trait::async_trait;
use error_stack::ResultExt;
use router_env::{instrument, tracing};
use super::{BoxedOperation, Domain, GetTracker, Operation, UpdateTracker, ValidateRequest};
use crate::{
core::{
errors::{self, RouterResult, StorageErrorExt},
payments::{self, helpers, operations, PaymentData},
},
routes::{app::ReqState, SessionState},
services,
types::{
self as core_types,
api::{self, PaymentIdTypeExt},
domain,
storage::{self, enums},
},
utils::OptionExt,
};
#[derive(Debug, Clone, Copy, router_derive::PaymentOperation)]
#[operation(operations = "all", flow = "extend_authorization")]
pub struct PaymentExtendAuthorization;
type PaymentExtendAuthorizationOperation<'b, F> =
BoxedOperation<'b, F, api::PaymentsExtendAuthorizationRequest, PaymentData<F>>;
#[async_trait]
impl<F: Send + Clone + Sync> GetTracker<F, PaymentData<F>, api::PaymentsExtendAuthorizationRequest>
for PaymentExtendAuthorization
{
#[instrument(skip_all)]
async fn get_trackers<'a>(
&'a self,
state: &'a SessionState,
payment_id: &api::PaymentIdType,
_request: &api::PaymentsExtendAuthorizationRequest,
platform: &domain::Platform,
_auth_flow: services::AuthFlow,
_header_payload: &hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<
operations::GetTrackerResponse<
'a,
F,
api::PaymentsExtendAuthorizationRequest,
PaymentData<F>,
>,
> {
let db = &*state.store;
let merchant_id = platform.get_processor().get_account().get_id();
let storage_scheme = platform.get_processor().get_account().storage_scheme;
let payment_id = payment_id
.get_payment_intent_id()
.change_context(errors::ApiErrorResponse::PaymentNotFound)?;
let payment_intent = db
.find_payment_intent_by_payment_id_merchant_id(
&payment_id,
merchant_id,
platform.get_processor().get_key_store(),
storage_scheme,
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
helpers::validate_payment_status_against_allowed_statuses(
payment_intent.status,
&[
enums::IntentStatus::RequiresCapture,
enums::IntentStatus::PartiallyAuthorizedAndRequiresCapture,
],
"extend authorization",
)?;
let payment_attempt = db
.find_payment_attempt_by_payment_id_merchant_id_attempt_id(
&payment_intent.payment_id,
merchant_id,
payment_intent.active_attempt.get_id().as_str(),
storage_scheme,
platform.get_processor().get_key_store(),
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
if !payment_attempt
.request_extended_authorization
.is_some_and(|request_extended_authorization| request_extended_authorization.is_true())
{
Err(errors::ApiErrorResponse::PreconditionFailed {
message:
"You cannot extend the authorization for this payment because authorization extension is not enabled.".to_owned(),
})?
}
let shipping_address = helpers::get_address_by_id(
state,
payment_intent.shipping_address_id.clone(),
platform.get_processor().get_key_store(),
&payment_intent.payment_id,
merchant_id,
platform.get_processor().get_account().storage_scheme,
)
.await?;
let billing_address = helpers::get_address_by_id(
state,
payment_intent.billing_address_id.clone(),
platform.get_processor().get_key_store(),
&payment_intent.payment_id,
merchant_id,
platform.get_processor().get_account().storage_scheme,
)
.await?;
let payment_method_billing = helpers::get_address_by_id(
state,
payment_attempt.payment_method_billing_address_id.clone(),
platform.get_processor().get_key_store(),
&payment_intent.payment_id,
merchant_id,
platform.get_processor().get_account().storage_scheme,
)
.await?;
let currency = payment_attempt.currency.get_required_value("currency")?;
let amount = payment_attempt.get_total_amount().into();
let profile_id = payment_intent
.profile_id
.as_ref()
.get_required_value("profile_id")
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("'profile_id' not set in payment intent")?;
let business_profile = db
.find_business_profile_by_profile_id(
platform.get_processor().get_key_store(),
profile_id,
)
.await
.to_not_found_response(errors::ApiErrorResponse::ProfileNotFound {
id: profile_id.get_string_repr().to_owned(),
})?;
let payment_data = PaymentData {
flow: PhantomData,
payment_intent,
payment_attempt,
currency,
amount,
email: None,
mandate_id: None,
mandate_connector: None,
setup_mandate: None,
customer_acceptance: None,
token: None,
token_data: None,
address: core_types::PaymentAddress::new(
shipping_address.as_ref().map(From::from),
billing_address.as_ref().map(From::from),
payment_method_billing.as_ref().map(From::from),
business_profile.use_billing_as_payment_method_billing,
),
confirm: None,
payment_method_data: None,
payment_method_token: None,
payment_method_info: None,
force_sync: None,
all_keys_required: None,
refunds: vec![],
disputes: vec![],
attempts: None,
sessions_token: vec![],
card_cvc: None,
creds_identifier: None,
pm_token: None,
connector_customer_id: None,
recurring_mandate_payment_data: None,
multiple_capture_data: None,
redirect_response: None,
surcharge_details: None,
frm_message: None,
payment_link_data: None,
incremental_authorization_details: None,
authorizations: vec![],
authentication: None,
recurring_details: None,
poll_config: None,
tax_data: None,
session_id: None,
service_details: None,
card_testing_guard_data: None,
vault_operation: None,
threeds_method_comp_ind: None,
whole_connector_response: None,
is_manual_retry_enabled: None,
is_l2_l3_enabled: false,
external_authentication_data: None,
};
let get_trackers_response = operations::GetTrackerResponse {
operation: Box::new(self),
customer_details: None,
payment_data,
business_profile,
mandate_type: None,
};
Ok(get_trackers_response)
}
}
#[async_trait]
impl<F: Clone + Send + Sync> Domain<F, api::PaymentsExtendAuthorizationRequest, PaymentData<F>>
for PaymentExtendAuthorization
{
#[instrument(skip_all)]
async fn populate_raw_customer_details<'a>(
&'a self,
_state: &SessionState,
_payment_data: &mut PaymentData<F>,
_request: Option<&payments::CustomerDetails>,
_processor: &domain::Processor,
) -> errors::CustomResult<(), errors::StorageError> {
Ok(())
}
#[instrument(skip_all)]
async fn get_or_create_customer_details<'a>(
&'a self,
_state: &SessionState,
_payment_data: &mut PaymentData<F>,
_request: Option<payments::CustomerDetails>,
_provider: &domain::Provider,
) -> errors::CustomResult<
(
PaymentExtendAuthorizationOperation<'a, F>,
Option<domain::Customer>,
),
errors::StorageError,
> {
Ok((Box::new(self), None))
}
#[instrument(skip_all)]
async fn make_pm_data<'a>(
&'a self,
_state: &'a SessionState,
_payment_data: &mut PaymentData<F>,
_storage_scheme: enums::MerchantStorageScheme,
_merchant_key_store: &domain::MerchantKeyStore,
_customer: &Option<domain::Customer>,
_business_profile: &domain::Profile,
_should_retry_with_pan: bool,
) -> RouterResult<(
PaymentExtendAuthorizationOperation<'a, F>,
Option<domain::PaymentMethodData>,
Option<String>,
)> {
Ok((Box::new(self), None, None))
}
async fn get_connector<'a>(
&'a self,
_platform: &domain::Platform,
state: &SessionState,
_request: &api::PaymentsExtendAuthorizationRequest,
_payment_intent: &storage::PaymentIntent,
) -> errors::CustomResult<api::ConnectorChoice, errors::ApiErrorResponse> {
helpers::get_connector_default(state, None).await
}
#[instrument(skip_all)]
async fn guard_payment_against_blocklist<'a>(
&'a self,
_state: &SessionState,
_platform: &domain::Platform,
_payment_data: &mut PaymentData<F>,
) -> errors::CustomResult<bool, errors::ApiErrorResponse> {
Ok(false)
}
}
#[async_trait]
impl<F: Clone + Sync> UpdateTracker<F, PaymentData<F>, api::PaymentsExtendAuthorizationRequest>
for PaymentExtendAuthorization
{
#[instrument(skip_all)]
async fn update_trackers<'b>(
&'b self,
_state: &'b SessionState,
_req_state: ReqState,
_processor: &domain::Processor,
payment_data: PaymentData<F>,
_customer: Option<domain::Customer>,
_frm_suggestion: Option<FrmSuggestion>,
_header_payload: hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<(PaymentExtendAuthorizationOperation<'b, F>, PaymentData<F>)>
where
F: 'b + Send,
{
Ok((Box::new(self), payment_data))
}
}
impl<F: Send + Clone + Sync>
ValidateRequest<F, api::PaymentsExtendAuthorizationRequest, PaymentData<F>>
for PaymentExtendAuthorization
{
#[instrument(skip_all)]
fn validate_request<'a, 'b>(
&'b self,
request: &api::PaymentsExtendAuthorizationRequest,
processor: &'a domain::Processor,
) -> RouterResult<(
PaymentExtendAuthorizationOperation<'b, F>,
operations::ValidateResult,
)> {
Ok((
Box::new(self),
operations::ValidateResult {
merchant_id: processor.get_account().get_id().to_owned(),
payment_id: api::PaymentIdType::PaymentIntentId(request.payment_id.to_owned()),
storage_scheme: processor.get_account().storage_scheme,
requeue: false,
},
))
}
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/payments/operations/payment_response.rs | crates/router/src/core/payments/operations/payment_response.rs | use std::{collections::HashMap, ops::Deref};
use api_models::payments::{ConnectorMandateReferenceId, MandateReferenceId};
#[cfg(feature = "dynamic_routing")]
use api_models::routing::RoutableConnectorChoice;
use async_trait::async_trait;
use common_enums::AuthorizationStatus;
#[cfg(all(feature = "v1", feature = "dynamic_routing"))]
use common_utils::ext_traits::ValueExt;
use common_utils::{
ext_traits::{AsyncExt, Encode},
types::{keymanager::KeyManagerState, ConnectorTransactionId, MinorUnit},
};
use error_stack::{report, ResultExt};
use futures::FutureExt;
#[cfg(feature = "v2")]
use hyperswitch_domain_models::payments::{
PaymentConfirmData, PaymentIntentData, PaymentStatusData,
};
use hyperswitch_domain_models::{behaviour::Conversion, payments::payment_attempt::PaymentAttempt};
#[cfg(feature = "v2")]
use masking::PeekInterface;
use router_derive;
use router_env::{instrument, logger, tracing};
use tracing_futures::Instrument;
use super::{Operation, OperationSessionSetters, PostUpdateTracker};
#[cfg(all(feature = "v1", feature = "dynamic_routing"))]
use crate::core::routing::helpers as routing_helpers;
#[cfg(feature = "v2")]
use crate::utils::OptionExt;
use crate::{
connector::utils::PaymentResponseRouterData,
consts,
core::{
card_testing_guard::utils as card_testing_guard_utils,
errors::{self, CustomResult, RouterResult, StorageErrorExt},
mandate,
payment_methods::{self, cards::create_encrypted_data},
payments::{
helpers::{
self as payments_helpers,
update_additional_payment_data_with_connector_response_pm_data,
},
tokenization,
types::MultipleCaptureData,
PaymentData, PaymentMethodChecker,
},
utils as core_utils,
},
routes::{metrics, SessionState},
types::{
self, domain,
storage::{self, enums},
transformers::{ForeignFrom, ForeignTryFrom},
CaptureSyncResponse, ErrorResponse,
},
utils,
};
#[cfg(feature = "v1")]
#[derive(Debug, Clone, Copy, router_derive::PaymentOperation)]
#[operation(
operations = "post_update_tracker",
flow = "sync_data, cancel_data, authorize_data, capture_data, complete_authorize_data, approve_data, reject_data, setup_mandate_data, session_data,incremental_authorization_data, sdk_session_update_data, post_session_tokens_data, update_metadata_data, cancel_post_capture_data, extend_authorization_data"
)]
pub struct PaymentResponse;
#[cfg(feature = "v2")]
#[derive(Debug, Clone, Copy)]
pub struct PaymentResponse;
#[cfg(feature = "v1")]
#[async_trait]
impl<F: Send + Clone> PostUpdateTracker<F, PaymentData<F>, types::PaymentsAuthorizeData>
for PaymentResponse
{
async fn update_tracker<'b>(
&'b self,
db: &'b SessionState,
mut payment_data: PaymentData<F>,
router_data: types::RouterData<
F,
types::PaymentsAuthorizeData,
types::PaymentsResponseData,
>,
key_store: &domain::MerchantKeyStore,
storage_scheme: enums::MerchantStorageScheme,
locale: &Option<String>,
#[cfg(all(feature = "v1", feature = "dynamic_routing"))] routable_connector: Vec<
RoutableConnectorChoice,
>,
#[cfg(all(feature = "v1", feature = "dynamic_routing"))] business_profile: &domain::Profile,
) -> RouterResult<PaymentData<F>>
where
F: 'b,
{
payment_data.mandate_id = payment_data
.mandate_id
.or_else(|| router_data.request.mandate_id.clone());
// update setup_future_usage incase it is downgraded to on-session
payment_data.payment_attempt.setup_future_usage_applied =
router_data.request.setup_future_usage;
payment_data = Box::pin(payment_response_update_tracker(
db,
payment_data,
router_data,
key_store,
storage_scheme,
locale,
#[cfg(all(feature = "v1", feature = "dynamic_routing"))]
routable_connector,
#[cfg(all(feature = "v1", feature = "dynamic_routing"))]
business_profile,
))
.await?;
Ok(payment_data)
}
#[cfg(feature = "v2")]
async fn save_pm_and_mandate<'b>(
&self,
state: &SessionState,
resp: &types::RouterData<F, types::PaymentsAuthorizeData, types::PaymentsResponseData>,
platform: &domain::Platform,
payment_data: &mut PaymentData<F>,
business_profile: &domain::Profile,
) -> CustomResult<(), errors::ApiErrorResponse>
where
F: 'b + Clone + Send + Sync,
{
todo!()
}
#[cfg(feature = "v1")]
async fn save_pm_and_mandate<'b>(
&self,
state: &SessionState,
resp: &types::RouterData<F, types::PaymentsAuthorizeData, types::PaymentsResponseData>,
platform: &domain::Platform,
payment_data: &mut PaymentData<F>,
business_profile: &domain::Profile,
) -> CustomResult<(), errors::ApiErrorResponse>
where
F: 'b + Clone + Send + Sync,
{
let customer_id = payment_data.payment_intent.customer_id.clone();
let save_payment_data = tokenization::SavePaymentMethodData::from(resp);
let payment_method_billing_address = payment_data.address.get_payment_method_billing();
let connector_name = payment_data
.payment_attempt
.connector
.clone()
.ok_or_else(|| {
logger::error!("Missing required Param connector_name");
errors::ApiErrorResponse::MissingRequiredField {
field_name: "connector_name",
}
})?;
let merchant_connector_id = payment_data.payment_attempt.merchant_connector_id.clone();
let billing_name = resp
.address
.get_payment_method_billing()
.and_then(|billing_details| billing_details.address.as_ref())
.and_then(|address| address.get_optional_full_name());
let mut should_avoid_saving = false;
let vault_operation = payment_data.vault_operation.clone();
let payment_method_info = payment_data.payment_method_info.clone();
if let Some(payment_method_info) = &payment_data.payment_method_info {
if payment_data.payment_intent.off_session.is_none() && resp.response.is_ok() {
should_avoid_saving = resp.request.payment_method_type
== Some(enums::PaymentMethodType::ApplePay)
|| resp.request.payment_method_type
== Some(enums::PaymentMethodType::GooglePay);
payment_methods::cards::update_last_used_at(
payment_method_info,
state,
platform.get_processor().get_account().storage_scheme,
platform.get_processor().get_key_store(),
)
.await
.map_err(|e| {
logger::error!("Failed to update last used at: {:?}", e);
})
.ok();
}
};
let connector_mandate_reference_id = payment_data
.payment_attempt
.connector_mandate_detail
.as_ref()
.map(|detail| ConnectorMandateReferenceId::foreign_from(detail.clone()));
let save_payment_call_future = Box::pin(tokenization::save_payment_method(
state,
connector_name.clone(),
save_payment_data,
customer_id.clone(),
platform,
resp.request.payment_method_type,
billing_name.clone(),
payment_method_billing_address,
business_profile,
connector_mandate_reference_id.clone(),
merchant_connector_id.clone(),
vault_operation.clone(),
payment_method_info.clone(),
payment_data.payment_method_token.clone(),
));
let is_connector_mandate = resp.request.customer_acceptance.is_some()
&& matches!(
resp.request.setup_future_usage,
Some(enums::FutureUsage::OffSession)
);
let is_legacy_mandate = resp.request.setup_mandate_details.is_some()
&& matches!(
resp.request.setup_future_usage,
Some(enums::FutureUsage::OffSession)
);
let storage_scheme = platform.get_processor().get_account().storage_scheme;
if is_legacy_mandate {
// Mandate is created on the application side and at the connector.
let tokenization::SavePaymentMethodDataResponse {
payment_method_id, ..
} = save_payment_call_future.await?;
let mandate_id = mandate::mandate_procedure(
state,
resp,
&customer_id.clone(),
payment_method_id.clone(),
merchant_connector_id.clone(),
platform.get_processor().get_account().storage_scheme,
payment_data.payment_intent.get_id(),
)
.await?;
payment_data.payment_attempt.payment_method_id = payment_method_id;
payment_data.payment_attempt.mandate_id = mandate_id;
Ok(())
} else if is_connector_mandate {
// The mandate is created on connector's end.
let save_payment_call_response = save_payment_call_future.await;
match save_payment_call_response {
Ok(tokenization::SavePaymentMethodDataResponse {
payment_method_id,
connector_mandate_reference_id,
..
}) => {
payment_data.payment_method_info = if let Some(payment_method_id) =
&payment_method_id
{
match state
.store
.find_payment_method(
platform.get_processor().get_key_store(),
payment_method_id,
storage_scheme,
)
.await
{
Ok(payment_method) => Some(payment_method),
Err(error) => {
if error.current_context().is_db_not_found() {
logger::info!("Payment Method not found in db {:?}", error);
None
} else {
Err(error)
.change_context(
errors::ApiErrorResponse::InternalServerError,
)
.attach_printable("Error retrieving payment method from db")
.map_err(|err| logger::error!(payment_method_retrieve=?err))
.ok()
}
}
}
} else {
None
};
payment_data.payment_attempt.payment_method_id = payment_method_id;
payment_data.payment_attempt.connector_mandate_detail =
connector_mandate_reference_id
.clone()
.map(ForeignFrom::foreign_from);
payment_data.set_mandate_id(api_models::payments::MandateIds {
mandate_id: None,
mandate_reference_id: connector_mandate_reference_id.map(
|connector_mandate_id| {
MandateReferenceId::ConnectorMandateId(connector_mandate_id)
},
),
})
}
Err(err) => {
logger::error!("Error while storing the payment method in locker {:?}", err);
}
}
Ok(())
} else if should_avoid_saving {
if let Some(pm_info) = &payment_data.payment_method_info {
payment_data.payment_attempt.payment_method_id = Some(pm_info.get_id().clone());
};
Ok(())
} else {
// Save card flow
let save_payment_data = tokenization::SavePaymentMethodData::from(resp);
let state = state.clone();
let customer_id = payment_data.payment_intent.customer_id.clone();
let payment_attempt = payment_data.payment_attempt.clone();
let business_profile = business_profile.clone();
let payment_method_type = resp.request.payment_method_type;
let payment_method_billing_address = payment_method_billing_address.cloned();
let payment_method_token = payment_data.payment_method_token.clone();
let cloned_platform = platform.clone();
logger::info!("Call to save_payment_method in locker");
let _task_handle = tokio::spawn(
async move {
logger::info!("Starting async call to save_payment_method in locker");
let result = Box::pin(tokenization::save_payment_method(
&state,
connector_name,
save_payment_data,
customer_id,
&cloned_platform,
payment_method_type,
billing_name,
payment_method_billing_address.as_ref(),
&business_profile,
connector_mandate_reference_id,
merchant_connector_id.clone(),
vault_operation.clone(),
payment_method_info.clone(),
payment_method_token.clone(),
))
.await;
if let Err(err) = result {
logger::error!("Asynchronously saving card in locker failed : {:?}", err);
} else if let Ok(tokenization::SavePaymentMethodDataResponse {
payment_method_id,
..
}) = result
{
let payment_attempt_update =
storage::PaymentAttemptUpdate::PaymentMethodDetailsUpdate {
payment_method_id,
updated_by: storage_scheme.clone().to_string(),
};
#[cfg(feature = "v1")]
let respond = state
.store
.update_payment_attempt_with_attempt_id(
payment_attempt,
payment_attempt_update,
storage_scheme,
cloned_platform.get_processor().get_key_store(),
)
.await;
#[cfg(feature = "v2")]
let respond = state
.store
.update_payment_attempt_with_attempt_id(
&(&state).into(),
&key_store.clone(),
payment_attempt,
payment_attempt_update,
storage_scheme,
)
.await;
if let Err(err) = respond {
logger::error!("Error updating payment attempt: {:?}", err);
};
}
}
.in_current_span(),
);
Ok(())
}
}
}
#[cfg(feature = "v1")]
#[async_trait]
impl<F: Clone> PostUpdateTracker<F, PaymentData<F>, types::PaymentsIncrementalAuthorizationData>
for PaymentResponse
{
async fn update_tracker<'b>(
&'b self,
state: &'b SessionState,
mut payment_data: PaymentData<F>,
router_data: types::RouterData<
F,
types::PaymentsIncrementalAuthorizationData,
types::PaymentsResponseData,
>,
key_store: &domain::MerchantKeyStore,
storage_scheme: enums::MerchantStorageScheme,
_locale: &Option<String>,
#[cfg(all(feature = "v1", feature = "dynamic_routing"))] _routable_connector: Vec<
RoutableConnectorChoice,
>,
#[cfg(all(feature = "v1", feature = "dynamic_routing"))]
_business_profile: &domain::Profile,
) -> RouterResult<PaymentData<F>>
where
F: 'b + Send,
{
let incremental_authorization_details = payment_data
.incremental_authorization_details
.clone()
.ok_or_else(|| {
report!(errors::ApiErrorResponse::InternalServerError)
.attach_printable("missing incremental_authorization_details in payment_data")
})?;
// Update payment_intent and payment_attempt 'amount' if incremental_authorization is successful
let (option_payment_attempt_update, option_payment_intent_update) = match router_data
.response
.clone()
{
Err(_) => (None, None),
Ok(types::PaymentsResponseData::IncrementalAuthorizationResponse {
status, ..
}) => {
if status == AuthorizationStatus::Success {
(
Some(
storage::PaymentAttemptUpdate::IncrementalAuthorizationAmountUpdate {
net_amount: hyperswitch_domain_models::payments::payment_attempt::NetAmount::new(
// Internally, `NetAmount` is computed as (order_amount + additional_amount), so we subtract here to avoid double-counting.
incremental_authorization_details.total_amount - payment_data.payment_attempt.net_amount.get_additional_amount(),
None,
None,
None,
None,
),
amount_capturable: incremental_authorization_details.total_amount,
},
),
Some(
storage::PaymentIntentUpdate::IncrementalAuthorizationAmountUpdate {
amount: incremental_authorization_details.total_amount - payment_data.payment_attempt.net_amount.get_additional_amount(),
},
),
)
} else {
(None, None)
}
}
_ => Err(errors::ApiErrorResponse::InternalServerError)
.attach_printable("unexpected response in incremental_authorization flow")?,
};
//payment_attempt update
if let Some(payment_attempt_update) = option_payment_attempt_update {
#[cfg(feature = "v1")]
{
payment_data.payment_attempt = state
.store
.update_payment_attempt_with_attempt_id(
payment_data.payment_attempt.clone(),
payment_attempt_update,
storage_scheme,
key_store,
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
}
#[cfg(feature = "v2")]
{
payment_data.payment_attempt = state
.store
.update_payment_attempt_with_attempt_id(
&state.into(),
key_store,
payment_data.payment_attempt.clone(),
payment_attempt_update,
storage_scheme,
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
}
}
// payment_intent update
if let Some(payment_intent_update) = option_payment_intent_update {
payment_data.payment_intent = state
.store
.update_payment_intent(
payment_data.payment_intent.clone(),
payment_intent_update,
key_store,
storage_scheme,
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
}
// Update the status of authorization record
let authorization_update = match &router_data.response {
Err(res) => Ok(storage::AuthorizationUpdate::StatusUpdate {
status: AuthorizationStatus::Failure,
error_code: Some(res.code.clone()),
error_message: Some(res.message.clone()),
connector_authorization_id: None,
}),
Ok(types::PaymentsResponseData::IncrementalAuthorizationResponse {
status,
error_code,
error_message,
connector_authorization_id,
}) => Ok(storage::AuthorizationUpdate::StatusUpdate {
status: status.clone(),
error_code: error_code.clone(),
error_message: error_message.clone(),
connector_authorization_id: connector_authorization_id.clone(),
}),
Ok(_) => Err(errors::ApiErrorResponse::InternalServerError)
.attach_printable("unexpected response in incremental_authorization flow"),
}?;
let authorization_id = incremental_authorization_details
.authorization_id
.clone()
.ok_or(
report!(errors::ApiErrorResponse::InternalServerError).attach_printable(
"missing authorization_id in incremental_authorization_details in payment_data",
),
)?;
state
.store
.update_authorization_by_merchant_id_authorization_id(
router_data.merchant_id.clone(),
authorization_id,
authorization_update,
)
.await
.to_not_found_response(errors::ApiErrorResponse::InternalServerError)
.attach_printable("failed while updating authorization")?;
//Fetch all the authorizations of the payment and send in incremental authorization response
let authorizations = state
.store
.find_all_authorizations_by_merchant_id_payment_id(
&router_data.merchant_id,
payment_data.payment_intent.get_id(),
)
.await
.to_not_found_response(errors::ApiErrorResponse::InternalServerError)
.attach_printable("failed while retrieving authorizations")?;
payment_data.authorizations = authorizations;
Ok(payment_data)
}
}
#[cfg(feature = "v1")]
#[async_trait]
impl<F: Clone> PostUpdateTracker<F, PaymentData<F>, types::PaymentsSyncData> for PaymentResponse {
async fn update_tracker<'b>(
&'b self,
db: &'b SessionState,
payment_data: PaymentData<F>,
router_data: types::RouterData<F, types::PaymentsSyncData, types::PaymentsResponseData>,
key_store: &domain::MerchantKeyStore,
storage_scheme: enums::MerchantStorageScheme,
locale: &Option<String>,
#[cfg(all(feature = "v1", feature = "dynamic_routing"))] routable_connector: Vec<
RoutableConnectorChoice,
>,
#[cfg(all(feature = "v1", feature = "dynamic_routing"))] business_profile: &domain::Profile,
) -> RouterResult<PaymentData<F>>
where
F: 'b + Send,
{
Box::pin(payment_response_update_tracker(
db,
payment_data,
router_data,
key_store,
storage_scheme,
locale,
#[cfg(all(feature = "v1", feature = "dynamic_routing"))]
routable_connector,
#[cfg(all(feature = "v1", feature = "dynamic_routing"))]
business_profile,
))
.await
}
async fn save_pm_and_mandate<'b>(
&self,
state: &SessionState,
resp: &types::RouterData<F, types::PaymentsSyncData, types::PaymentsResponseData>,
platform: &domain::Platform,
payment_data: &mut PaymentData<F>,
_business_profile: &domain::Profile,
) -> CustomResult<(), errors::ApiErrorResponse>
where
F: 'b + Clone + Send + Sync,
{
let (connector_mandate_id, mandate_metadata, connector_mandate_request_reference_id) = resp
.response
.clone()
.ok()
.and_then(|resp| {
if let types::PaymentsResponseData::TransactionResponse {
mandate_reference, ..
} = resp
{
mandate_reference.map(|mandate_ref| {
(
mandate_ref.connector_mandate_id.clone(),
mandate_ref.mandate_metadata.clone(),
mandate_ref.connector_mandate_request_reference_id.clone(),
)
})
} else {
None
}
})
.unwrap_or((None, None, None));
update_connector_mandate_details_for_the_flow(
connector_mandate_id,
mandate_metadata,
connector_mandate_request_reference_id,
payment_data,
)?;
update_payment_method_status_and_ntid(
state,
platform.get_processor().get_key_store(),
payment_data,
resp.status,
resp.response.clone(),
platform.get_processor().get_account().storage_scheme,
)
.await?;
Ok(())
}
}
#[cfg(feature = "v1")]
#[async_trait]
impl<F: Clone> PostUpdateTracker<F, PaymentData<F>, types::PaymentsSessionData>
for PaymentResponse
{
async fn update_tracker<'b>(
&'b self,
db: &'b SessionState,
mut payment_data: PaymentData<F>,
router_data: types::RouterData<F, types::PaymentsSessionData, types::PaymentsResponseData>,
key_store: &domain::MerchantKeyStore,
storage_scheme: enums::MerchantStorageScheme,
locale: &Option<String>,
#[cfg(all(feature = "v1", feature = "dynamic_routing"))] routable_connector: Vec<
RoutableConnectorChoice,
>,
#[cfg(all(feature = "v1", feature = "dynamic_routing"))] business_profile: &domain::Profile,
) -> RouterResult<PaymentData<F>>
where
F: 'b + Send,
{
payment_data = Box::pin(payment_response_update_tracker(
db,
payment_data,
router_data,
key_store,
storage_scheme,
locale,
#[cfg(all(feature = "v1", feature = "dynamic_routing"))]
routable_connector,
#[cfg(all(feature = "v1", feature = "dynamic_routing"))]
business_profile,
))
.await?;
Ok(payment_data)
}
}
#[cfg(feature = "v1")]
#[async_trait]
impl<F: Clone> PostUpdateTracker<F, PaymentData<F>, types::SdkPaymentsSessionUpdateData>
for PaymentResponse
{
async fn update_tracker<'b>(
&'b self,
db: &'b SessionState,
mut payment_data: PaymentData<F>,
router_data: types::RouterData<
F,
types::SdkPaymentsSessionUpdateData,
types::PaymentsResponseData,
>,
key_store: &domain::MerchantKeyStore,
storage_scheme: enums::MerchantStorageScheme,
_locale: &Option<String>,
#[cfg(feature = "dynamic_routing")] _routable_connector: Vec<RoutableConnectorChoice>,
#[cfg(feature = "dynamic_routing")] _business_profile: &domain::Profile,
) -> RouterResult<PaymentData<F>>
where
F: 'b + Send,
{
let connector = payment_data
.payment_attempt
.connector
.clone()
.ok_or(errors::ApiErrorResponse::InternalServerError)
.attach_printable("connector not found")?;
let key_manager_state = db.into();
// For PayPal, if we call TaxJar for tax calculation, we need to call the connector again to update the order amount so that we can confirm the updated amount and order details. Therefore, we will store the required changes in the database during the post_update_tracker call.
if payment_data.should_update_in_post_update_tracker() {
match router_data.response.clone() {
Ok(types::PaymentsResponseData::PaymentResourceUpdateResponse { status }) => {
if status.is_success() {
let shipping_address = payment_data
.tax_data
.clone()
.map(|tax_data| tax_data.shipping_details);
let shipping_details = shipping_address
.clone()
.async_map(|shipping_details| {
create_encrypted_data(
&key_manager_state,
key_store,
shipping_details,
)
})
.await
.transpose()
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Unable to encrypt shipping details")?;
let shipping_address =
payments_helpers::create_or_update_address_for_payment_by_request(
db,
shipping_address.map(From::from).as_ref(),
payment_data.payment_intent.shipping_address_id.as_deref(),
&payment_data.payment_intent.merchant_id,
payment_data.payment_intent.customer_id.as_ref(),
key_store,
&payment_data.payment_intent.payment_id,
storage_scheme,
)
.await?;
let payment_intent_update = hyperswitch_domain_models::payments::payment_intent::PaymentIntentUpdate::SessionResponseUpdate {
tax_details: payment_data.payment_intent.tax_details.clone().ok_or(errors::ApiErrorResponse::InternalServerError).attach_printable("payment_intent.tax_details not found")?,
shipping_address_id: shipping_address.map(|address| address.address_id),
updated_by: payment_data.payment_intent.updated_by.clone(),
shipping_details,
};
let m_db = db.clone().store;
let payment_intent = payment_data.payment_intent.clone();
let updated_payment_intent = m_db
.update_payment_intent(
payment_intent,
payment_intent_update,
key_store,
storage_scheme,
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
payment_data.payment_intent = updated_payment_intent;
} else {
router_data.response.map_err(|err| {
errors::ApiErrorResponse::ExternalConnectorError {
code: err.code,
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | true |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/payments/operations/payment_capture.rs | crates/router/src/core/payments/operations/payment_capture.rs | use std::{marker::PhantomData, ops::Deref};
use api_models::enums::FrmSuggestion;
use async_trait::async_trait;
use common_utils::ext_traits::AsyncExt;
use error_stack::ResultExt;
use router_env::{instrument, tracing};
use super::{BoxedOperation, Domain, GetTracker, Operation, UpdateTracker, ValidateRequest};
use crate::{
core::{
errors::{self, RouterResult, StorageErrorExt},
payments::{self, helpers, operations, types::MultipleCaptureData},
},
events::audit_events::{AuditEvent, AuditEventType},
routes::{app::ReqState, SessionState},
services,
types::{
self as core_types,
api::{self, PaymentIdTypeExt},
domain,
storage::{self, enums, payment_attempt::PaymentAttemptExt},
},
utils::OptionExt,
};
#[derive(Debug, Clone, Copy, router_derive::PaymentOperation)]
#[operation(operations = "all", flow = "capture")]
pub struct PaymentCapture;
type PaymentCaptureOperation<'b, F> =
BoxedOperation<'b, F, api::PaymentsCaptureRequest, payments::PaymentData<F>>;
#[async_trait]
impl<F: Send + Clone + Sync> GetTracker<F, payments::PaymentData<F>, api::PaymentsCaptureRequest>
for PaymentCapture
{
#[instrument(skip_all)]
async fn get_trackers<'a>(
&'a self,
state: &'a SessionState,
payment_id: &api::PaymentIdType,
request: &api::PaymentsCaptureRequest,
platform: &domain::Platform,
_auth_flow: services::AuthFlow,
_header_payload: &hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<
operations::GetTrackerResponse<
'a,
F,
api::PaymentsCaptureRequest,
payments::PaymentData<F>,
>,
> {
let db = &*state.store;
let merchant_id = platform.get_processor().get_account().get_id();
let storage_scheme = platform.get_processor().get_account().storage_scheme;
let (payment_intent, mut payment_attempt, currency, amount);
let payment_id = payment_id
.get_payment_intent_id()
.change_context(errors::ApiErrorResponse::PaymentNotFound)?;
payment_intent = db
.find_payment_intent_by_payment_id_merchant_id(
&payment_id,
merchant_id,
platform.get_processor().get_key_store(),
storage_scheme,
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
payment_attempt = db
.find_payment_attempt_by_payment_id_merchant_id_attempt_id(
&payment_intent.payment_id,
merchant_id,
payment_intent.active_attempt.get_id().as_str(),
storage_scheme,
platform.get_processor().get_key_store(),
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
payment_attempt
.amount_to_capture
.update_value(request.amount_to_capture);
let capture_method = payment_attempt
.capture_method
.get_required_value("capture_method")?;
helpers::validate_status_with_capture_method(payment_intent.status, capture_method)?;
if !*payment_attempt
.is_overcapture_enabled
.unwrap_or_default()
.deref()
{
helpers::validate_amount_to_capture(
payment_attempt.amount_capturable.get_amount_as_i64(),
request
.amount_to_capture
.map(|capture_amount| capture_amount.get_amount_as_i64()),
)?;
}
helpers::validate_capture_method(capture_method)?;
let multiple_capture_data = if capture_method == enums::CaptureMethod::ManualMultiple {
let amount_to_capture = request
.amount_to_capture
.get_required_value("amount_to_capture")?;
helpers::validate_amount_to_capture(
payment_attempt.amount_capturable.get_amount_as_i64(),
Some(amount_to_capture.get_amount_as_i64()),
)?;
let previous_captures = db
.find_all_captures_by_merchant_id_payment_id_authorized_attempt_id(
&payment_attempt.merchant_id,
&payment_attempt.payment_id,
&payment_attempt.attempt_id,
storage_scheme,
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
let capture = db
.insert_capture(
payment_attempt
.make_new_capture(amount_to_capture, enums::CaptureStatus::Started)?,
storage_scheme,
)
.await
.to_not_found_response(errors::ApiErrorResponse::DuplicatePayment {
payment_id: payment_id.clone(),
})?;
Some(MultipleCaptureData::new_for_create(
previous_captures,
capture,
))
} else {
None
};
currency = payment_attempt.currency.get_required_value("currency")?;
amount = payment_attempt.get_total_amount().into();
let shipping_address = helpers::get_address_by_id(
state,
payment_intent.shipping_address_id.clone(),
platform.get_processor().get_key_store(),
&payment_intent.payment_id,
merchant_id,
platform.get_processor().get_account().storage_scheme,
)
.await?;
let billing_address = helpers::get_address_by_id(
state,
payment_intent.billing_address_id.clone(),
platform.get_processor().get_key_store(),
&payment_intent.payment_id,
merchant_id,
platform.get_processor().get_account().storage_scheme,
)
.await?;
let payment_method_billing = helpers::get_address_by_id(
state,
payment_attempt.payment_method_billing_address_id.clone(),
platform.get_processor().get_key_store(),
&payment_intent.payment_id,
merchant_id,
platform.get_processor().get_account().storage_scheme,
)
.await?;
let creds_identifier = request
.merchant_connector_details
.as_ref()
.map(|mcd| mcd.creds_identifier.to_owned());
request
.merchant_connector_details
.to_owned()
.async_map(|mcd| async {
helpers::insert_merchant_connector_creds_to_config(
db,
platform.get_processor(),
mcd,
)
.await
})
.await
.transpose()?;
let profile_id = payment_intent
.profile_id
.as_ref()
.get_required_value("profile_id")
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("'profile_id' not set in payment intent")?;
let business_profile = db
.find_business_profile_by_profile_id(
platform.get_processor().get_key_store(),
profile_id,
)
.await
.to_not_found_response(errors::ApiErrorResponse::ProfileNotFound {
id: profile_id.get_string_repr().to_owned(),
})?;
let payment_data = payments::PaymentData {
flow: PhantomData,
payment_intent,
payment_attempt,
currency,
force_sync: None,
all_keys_required: None,
amount,
email: None,
mandate_id: None,
mandate_connector: None,
setup_mandate: None,
customer_acceptance: None,
token: None,
token_data: None,
address: core_types::PaymentAddress::new(
shipping_address.as_ref().map(From::from),
billing_address.as_ref().map(From::from),
payment_method_billing.as_ref().map(From::from),
business_profile.use_billing_as_payment_method_billing,
),
confirm: None,
payment_method_data: None,
payment_method_token: None,
payment_method_info: None,
refunds: vec![],
disputes: vec![],
attempts: None,
sessions_token: vec![],
card_cvc: None,
creds_identifier,
pm_token: None,
connector_customer_id: None,
recurring_mandate_payment_data: None,
multiple_capture_data,
redirect_response: None,
surcharge_details: None,
frm_message: None,
payment_link_data: None,
incremental_authorization_details: None,
authorizations: vec![],
authentication: None,
recurring_details: None,
poll_config: None,
tax_data: None,
session_id: None,
service_details: None,
card_testing_guard_data: None,
vault_operation: None,
threeds_method_comp_ind: None,
whole_connector_response: None,
is_manual_retry_enabled: None,
is_l2_l3_enabled: false,
external_authentication_data: None,
};
let get_trackers_response = operations::GetTrackerResponse {
operation: Box::new(self),
customer_details: None,
payment_data,
business_profile,
mandate_type: None,
};
Ok(get_trackers_response)
}
}
#[async_trait]
impl<F: Clone + Sync> UpdateTracker<F, payments::PaymentData<F>, api::PaymentsCaptureRequest>
for PaymentCapture
{
#[instrument(skip_all)]
async fn update_trackers<'b>(
&'b self,
db: &'b SessionState,
req_state: ReqState,
processor: &domain::Processor,
mut payment_data: payments::PaymentData<F>,
_customer: Option<domain::Customer>,
_frm_suggestion: Option<FrmSuggestion>,
_header_payload: hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<(PaymentCaptureOperation<'b, F>, payments::PaymentData<F>)>
where
F: 'b + Send,
{
let storage_scheme = processor.get_account().storage_scheme;
let merchant_key_store = processor.get_key_store();
payment_data.payment_attempt = if payment_data.multiple_capture_data.is_some()
|| payment_data.payment_attempt.amount_to_capture.is_some()
{
let multiple_capture_count = payment_data
.multiple_capture_data
.as_ref()
.map(|multiple_capture_data| multiple_capture_data.get_captures_count())
.transpose()?;
let amount_to_capture = payment_data.payment_attempt.amount_to_capture;
db.store
.update_payment_attempt_with_attempt_id(
payment_data.payment_attempt,
storage::PaymentAttemptUpdate::CaptureUpdate {
amount_to_capture,
multiple_capture_count,
updated_by: storage_scheme.to_string(),
},
storage_scheme,
merchant_key_store,
)
.await
.to_not_found_response(errors::ApiErrorResponse::InternalServerError)?
} else {
payment_data.payment_attempt
};
let capture_amount = payment_data.payment_attempt.amount_to_capture;
let multiple_capture_count = payment_data.payment_attempt.multiple_capture_count;
req_state
.event_context
.event(AuditEvent::new(AuditEventType::PaymentCapture {
capture_amount,
multiple_capture_count,
}))
.with(payment_data.to_event())
.emit();
Ok((Box::new(self), payment_data))
}
}
impl<F: Send + Clone + Sync>
ValidateRequest<F, api::PaymentsCaptureRequest, payments::PaymentData<F>> for PaymentCapture
{
#[instrument(skip_all)]
fn validate_request<'a, 'b>(
&'b self,
request: &api::PaymentsCaptureRequest,
processor: &'a domain::Processor,
) -> RouterResult<(PaymentCaptureOperation<'b, F>, operations::ValidateResult)> {
Ok((
Box::new(self),
operations::ValidateResult {
merchant_id: processor.get_account().get_id().to_owned(),
payment_id: api::PaymentIdType::PaymentIntentId(request.payment_id.to_owned()),
storage_scheme: processor.get_account().storage_scheme,
requeue: false,
},
))
}
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/payments/operations/payment_session.rs | crates/router/src/core/payments/operations/payment_session.rs | use std::marker::PhantomData;
use api_models::{admin::PaymentMethodsEnabled, enums::FrmSuggestion};
use async_trait::async_trait;
use common_utils::ext_traits::{AsyncExt, ValueExt};
use error_stack::ResultExt;
use router_derive::PaymentOperation;
use router_env::{instrument, logger, tracing};
use super::{BoxedOperation, Domain, GetTracker, Operation, UpdateTracker, ValidateRequest};
use crate::{
core::{
errors::{self, RouterResult, StorageErrorExt},
payments::{self, helpers, operations, PaymentData},
},
routes::{app::ReqState, SessionState},
services,
types::{
api::{self, PaymentIdTypeExt},
domain,
storage::{self, enums as storage_enums},
},
utils::OptionExt,
};
#[derive(Debug, Clone, Copy, PaymentOperation)]
#[operation(operations = "all", flow = "session")]
pub struct PaymentSession;
type PaymentSessionOperation<'b, F> =
BoxedOperation<'b, F, api::PaymentsSessionRequest, PaymentData<F>>;
#[async_trait]
impl<F: Send + Clone + Sync> GetTracker<F, PaymentData<F>, api::PaymentsSessionRequest>
for PaymentSession
{
#[instrument(skip_all)]
async fn get_trackers<'a>(
&'a self,
state: &'a SessionState,
payment_id: &api::PaymentIdType,
request: &api::PaymentsSessionRequest,
platform: &domain::Platform,
_auth_flow: services::AuthFlow,
_header_payload: &hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<
operations::GetTrackerResponse<'a, F, api::PaymentsSessionRequest, PaymentData<F>>,
> {
let payment_id = payment_id
.get_payment_intent_id()
.change_context(errors::ApiErrorResponse::PaymentNotFound)?;
let db = &*state.store;
let merchant_id = platform.get_processor().get_account().get_id();
let storage_scheme = platform.get_processor().get_account().storage_scheme;
let mut payment_intent = db
.find_payment_intent_by_payment_id_merchant_id(
&payment_id,
merchant_id,
platform.get_processor().get_key_store(),
storage_scheme,
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
// TODO (#7195): Add platform merchant account validation once publishable key auth is solved
helpers::validate_payment_status_against_not_allowed_statuses(
payment_intent.status,
&[
storage_enums::IntentStatus::Failed,
storage_enums::IntentStatus::Succeeded,
],
"create a session token for",
)?;
helpers::authenticate_client_secret(Some(&request.client_secret), &payment_intent)?;
let mut payment_attempt = db
.find_payment_attempt_by_payment_id_merchant_id_attempt_id(
&payment_intent.payment_id,
merchant_id,
payment_intent.active_attempt.get_id().as_str(),
storage_scheme,
platform.get_processor().get_key_store(),
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
let currency = payment_intent.currency.get_required_value("currency")?;
payment_attempt.payment_method = Some(storage_enums::PaymentMethod::Wallet);
let amount = payment_attempt.get_total_amount().into();
let shipping_address = helpers::get_address_by_id(
state,
payment_intent.shipping_address_id.clone(),
platform.get_processor().get_key_store(),
&payment_intent.payment_id,
merchant_id,
platform.get_processor().get_account().storage_scheme,
)
.await?;
let billing_address = helpers::get_address_by_id(
state,
payment_intent.billing_address_id.clone(),
platform.get_processor().get_key_store(),
&payment_intent.payment_id,
merchant_id,
platform.get_processor().get_account().storage_scheme,
)
.await?;
let payment_method_billing = helpers::get_address_by_id(
state,
payment_attempt.payment_method_billing_address_id.clone(),
platform.get_processor().get_key_store(),
&payment_intent.payment_id,
merchant_id,
platform.get_processor().get_account().storage_scheme,
)
.await?;
payment_intent.shipping_address_id = shipping_address.clone().map(|x| x.address_id);
payment_intent.billing_address_id = billing_address.clone().map(|x| x.address_id);
let customer_details = payments::CustomerDetails {
customer_id: payment_intent.customer_id.clone(),
name: None,
email: None,
phone: None,
phone_country_code: None,
tax_registration_id: None,
};
let creds_identifier = request
.merchant_connector_details
.as_ref()
.map(|mcd| mcd.creds_identifier.to_owned());
request
.merchant_connector_details
.to_owned()
.async_map(|mcd| async {
helpers::insert_merchant_connector_creds_to_config(
db,
platform.get_processor(),
mcd,
)
.await
})
.await
.transpose()?;
let profile_id = payment_intent
.profile_id
.as_ref()
.get_required_value("profile_id")
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("'profile_id' not set in payment intent")?;
let business_profile = db
.find_business_profile_by_profile_id(
platform.get_processor().get_key_store(),
profile_id,
)
.await
.to_not_found_response(errors::ApiErrorResponse::ProfileNotFound {
id: profile_id.get_string_repr().to_owned(),
})?;
let payment_data = PaymentData {
flow: PhantomData,
payment_intent,
payment_attempt,
currency,
amount,
email: None,
mandate_id: None,
mandate_connector: None,
customer_acceptance: None,
token: None,
token_data: None,
setup_mandate: None,
address: payments::PaymentAddress::new(
shipping_address.as_ref().map(From::from),
billing_address.as_ref().map(From::from),
payment_method_billing.as_ref().map(From::from),
business_profile.use_billing_as_payment_method_billing,
),
confirm: None,
payment_method_data: None,
payment_method_token: None,
payment_method_info: None,
force_sync: None,
all_keys_required: None,
refunds: vec![],
disputes: vec![],
attempts: None,
sessions_token: vec![],
card_cvc: None,
creds_identifier,
pm_token: None,
connector_customer_id: None,
recurring_mandate_payment_data: None,
multiple_capture_data: None,
redirect_response: None,
surcharge_details: None,
frm_message: None,
payment_link_data: None,
incremental_authorization_details: None,
authorizations: vec![],
authentication: None,
recurring_details: None,
poll_config: None,
tax_data: None,
session_id: None,
service_details: None,
card_testing_guard_data: None,
vault_operation: None,
threeds_method_comp_ind: None,
whole_connector_response: None,
is_manual_retry_enabled: None,
is_l2_l3_enabled: false,
external_authentication_data: None,
};
let get_trackers_response = operations::GetTrackerResponse {
operation: Box::new(self),
customer_details: Some(customer_details),
payment_data,
business_profile,
mandate_type: None,
};
Ok(get_trackers_response)
}
}
#[async_trait]
impl<F: Clone + Sync> UpdateTracker<F, PaymentData<F>, api::PaymentsSessionRequest>
for PaymentSession
{
#[instrument(skip_all)]
async fn update_trackers<'b>(
&'b self,
state: &'b SessionState,
_req_state: ReqState,
processor: &domain::Processor,
mut payment_data: PaymentData<F>,
_customer: Option<domain::Customer>,
_frm_suggestion: Option<FrmSuggestion>,
_header_payload: hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<(PaymentSessionOperation<'b, F>, PaymentData<F>)>
where
F: 'b + Send,
{
let storage_scheme = processor.get_account().storage_scheme;
let key_store = processor.get_key_store();
let metadata = payment_data.payment_intent.metadata.clone();
payment_data.payment_intent = match metadata {
Some(metadata) => state
.store
.update_payment_intent(
payment_data.payment_intent,
storage::PaymentIntentUpdate::MetadataUpdate {
metadata,
updated_by: storage_scheme.to_string(),
},
key_store,
storage_scheme,
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?,
None => payment_data.payment_intent,
};
Ok((Box::new(self), payment_data))
}
}
impl<F: Send + Clone + Sync> ValidateRequest<F, api::PaymentsSessionRequest, PaymentData<F>>
for PaymentSession
{
#[instrument(skip_all)]
fn validate_request<'a, 'b>(
&'b self,
request: &api::PaymentsSessionRequest,
processor: &'a domain::Processor,
) -> RouterResult<(PaymentSessionOperation<'b, F>, operations::ValidateResult)> {
//paymentid is already generated and should be sent in the request
let given_payment_id = request.payment_id.clone();
Ok((
Box::new(self),
operations::ValidateResult {
merchant_id: processor.get_account().get_id().to_owned(),
payment_id: api::PaymentIdType::PaymentIntentId(given_payment_id),
storage_scheme: processor.get_account().storage_scheme,
requeue: false,
},
))
}
}
#[async_trait]
impl<
F: Clone + Send,
Op: Send + Sync + Operation<F, api::PaymentsSessionRequest, Data = PaymentData<F>>,
> Domain<F, api::PaymentsSessionRequest, PaymentData<F>> for Op
where
for<'a> &'a Op: Operation<F, api::PaymentsSessionRequest, Data = PaymentData<F>>,
{
#[instrument(skip_all)]
async fn populate_raw_customer_details<'a>(
&'a self,
state: &SessionState,
payment_data: &mut PaymentData<F>,
request: Option<&payments::CustomerDetails>,
processor: &domain::Processor,
) -> errors::CustomResult<(), errors::StorageError> {
helpers::populate_raw_customer_details(state, payment_data, request, processor).await
}
#[instrument(skip_all)]
async fn get_or_create_customer_details<'a>(
&'a self,
state: &SessionState,
payment_data: &mut PaymentData<F>,
request: Option<payments::CustomerDetails>,
provider: &domain::Provider,
) -> errors::CustomResult<
(PaymentSessionOperation<'a, F>, Option<domain::Customer>),
errors::StorageError,
> {
match provider.get_account().merchant_account_type {
common_enums::MerchantAccountType::Standard => {
helpers::create_customer_if_not_exist(
state,
Box::new(self),
payment_data,
request,
provider,
)
.await
}
common_enums::MerchantAccountType::Platform => {
let customer = helpers::get_customer_if_exists(
state,
request.as_ref().and_then(|r| r.customer_id.as_ref()),
payment_data.payment_intent.customer_id.as_ref(),
provider,
)
.await?
.inspect(|cust| {
payment_data.email = payment_data
.email
.clone()
.or_else(|| cust.email.clone().map(Into::into));
});
Ok((Box::new(self), customer))
}
common_enums::MerchantAccountType::Connected => {
Err(errors::StorageError::ValueNotFound(
"Connected merchant cannot be a provider".to_string(),
)
.into())
}
}
}
#[instrument(skip_all)]
async fn make_pm_data<'b>(
&'b self,
_state: &'b SessionState,
_payment_data: &mut PaymentData<F>,
_storage_scheme: storage_enums::MerchantStorageScheme,
_merchant_key_store: &domain::MerchantKeyStore,
_customer: &Option<domain::Customer>,
_business_profile: &domain::Profile,
_should_retry_with_pan: bool,
) -> RouterResult<(
PaymentSessionOperation<'b, F>,
Option<domain::PaymentMethodData>,
Option<String>,
)> {
//No payment method data for this operation
Ok((Box::new(self), None, None))
}
/// Returns `SessionConnectorDatas`
/// Steps carried out in this function
/// Get all the `merchant_connector_accounts` which are not disabled
/// Filter out connectors which have `invoke_sdk_client` enabled in `payment_method_types`
/// If session token is requested for certain wallets only, then return them, else
/// return all eligible connectors
///
/// `GetToken` parameter specifies whether to get the session token from connector integration
/// or from separate implementation ( for googlepay - from metadata and applepay - from metadata and call connector)
async fn get_connector<'a>(
&'a self,
platform: &domain::Platform,
state: &SessionState,
request: &api::PaymentsSessionRequest,
payment_intent: &storage::PaymentIntent,
) -> RouterResult<api::ConnectorChoice> {
let db = &state.store;
let all_connector_accounts = db
.find_merchant_connector_account_by_merchant_id_and_disabled_list(
platform.get_processor().get_account().get_id(),
false,
platform.get_processor().get_key_store(),
)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Database error when querying for merchant connector accounts")?;
let profile_id = payment_intent
.profile_id
.clone()
.get_required_value("profile_id")
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("profile_id is not set in payment_intent")?;
let filtered_connector_accounts = all_connector_accounts
.filter_based_on_profile_and_connector_type(
&profile_id,
common_enums::ConnectorType::PaymentProcessor,
);
let requested_payment_method_types = request.wallets.clone();
let mut connector_and_supporting_payment_method_type = Vec::new();
filtered_connector_accounts
.iter()
.for_each(|connector_account| {
let res = connector_account
.payment_methods_enabled
.clone()
.unwrap_or_default()
.into_iter()
.map(|payment_methods_enabled| {
payment_methods_enabled
.parse_value::<PaymentMethodsEnabled>("payment_methods_enabled")
})
.filter_map(|parsed_payment_method_result| {
parsed_payment_method_result
.inspect_err(|err| {
logger::error!(session_token_parsing_error=?err);
})
.ok()
})
.flat_map(|parsed_payment_methods_enabled| {
parsed_payment_methods_enabled
.payment_method_types
.unwrap_or_default()
.into_iter()
.filter(|payment_method_type| {
let is_invoke_sdk_client = matches!(
payment_method_type.payment_experience,
Some(api_models::enums::PaymentExperience::InvokeSdkClient)
);
// If session token is requested for the payment method type,
// filter it out
// if not, then create all sessions tokens
let is_sent_in_request = requested_payment_method_types
.contains(&payment_method_type.payment_method_type)
|| requested_payment_method_types.is_empty();
is_invoke_sdk_client && is_sent_in_request
})
.map(|payment_method_type| {
(
connector_account,
payment_method_type.payment_method_type,
parsed_payment_methods_enabled.payment_method,
)
})
.collect::<Vec<_>>()
})
.collect::<Vec<_>>();
connector_and_supporting_payment_method_type.extend(res);
});
let mut session_connector_data = api::SessionConnectorDatas::with_capacity(
connector_and_supporting_payment_method_type.len(),
);
for (merchant_connector_account, payment_method_type, payment_method) in
connector_and_supporting_payment_method_type
{
if let Ok(connector_data) = helpers::get_connector_data_with_token(
state,
merchant_connector_account.connector_name.to_string(),
Some(merchant_connector_account.get_id()),
payment_method_type,
) {
#[cfg(feature = "v1")]
{
let new_session_connector_data = api::SessionConnectorData::new(
payment_method_type,
connector_data,
merchant_connector_account.business_sub_label.clone(),
payment_method,
);
session_connector_data.push(new_session_connector_data)
}
#[cfg(feature = "v2")]
{
let new_session_connector_data =
api::SessionConnectorData::new(payment_method_type, connector_data, None);
session_connector_data.push(new_session_connector_data)
}
};
}
Ok(api::ConnectorChoice::SessionMultiple(
session_connector_data,
))
}
#[instrument(skip_all)]
async fn guard_payment_against_blocklist<'a>(
&'a self,
_state: &SessionState,
_platform: &domain::Platform,
_payment_data: &mut PaymentData<F>,
) -> errors::CustomResult<bool, errors::ApiErrorResponse> {
Ok(false)
}
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/payments/operations/payment_cancel_post_capture.rs | crates/router/src/core/payments/operations/payment_cancel_post_capture.rs | use std::marker::PhantomData;
use api_models::enums::FrmSuggestion;
use async_trait::async_trait;
use error_stack::ResultExt;
use router_env::{instrument, tracing};
use super::{BoxedOperation, Domain, GetTracker, Operation, UpdateTracker, ValidateRequest};
use crate::{
core::{
errors::{self, RouterResult, StorageErrorExt},
payments::{self, helpers, operations, PaymentData},
},
routes::{app::ReqState, SessionState},
services,
types::{
self as core_types,
api::{self, PaymentIdTypeExt},
domain,
storage::{self, enums},
},
utils::OptionExt,
};
#[derive(Debug, Clone, Copy, router_derive::PaymentOperation)]
#[operation(operations = "all", flow = "cancel_post_capture")]
pub struct PaymentCancelPostCapture;
type PaymentCancelPostCaptureOperation<'b, F> =
BoxedOperation<'b, F, api::PaymentsCancelPostCaptureRequest, PaymentData<F>>;
#[async_trait]
impl<F: Send + Clone + Sync> GetTracker<F, PaymentData<F>, api::PaymentsCancelPostCaptureRequest>
for PaymentCancelPostCapture
{
#[instrument(skip_all)]
async fn get_trackers<'a>(
&'a self,
state: &'a SessionState,
payment_id: &api::PaymentIdType,
request: &api::PaymentsCancelPostCaptureRequest,
platform: &domain::Platform,
_auth_flow: services::AuthFlow,
_header_payload: &hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<
operations::GetTrackerResponse<
'a,
F,
api::PaymentsCancelPostCaptureRequest,
PaymentData<F>,
>,
> {
let db = &*state.store;
let merchant_id = platform.get_processor().get_account().get_id();
let storage_scheme = platform.get_processor().get_account().storage_scheme;
let payment_id = payment_id
.get_payment_intent_id()
.change_context(errors::ApiErrorResponse::PaymentNotFound)?;
let payment_intent = db
.find_payment_intent_by_payment_id_merchant_id(
&payment_id,
merchant_id,
platform.get_processor().get_key_store(),
storage_scheme,
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
helpers::validate_payment_status_against_allowed_statuses(
payment_intent.status,
&[
enums::IntentStatus::Succeeded,
enums::IntentStatus::PartiallyCaptured,
enums::IntentStatus::PartiallyCapturedAndCapturable,
],
"cancel_post_capture",
)?;
let mut payment_attempt = db
.find_payment_attempt_by_payment_id_merchant_id_attempt_id(
&payment_intent.payment_id,
merchant_id,
payment_intent.active_attempt.get_id().as_str(),
storage_scheme,
platform.get_processor().get_key_store(),
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
let shipping_address = helpers::get_address_by_id(
state,
payment_intent.shipping_address_id.clone(),
platform.get_processor().get_key_store(),
&payment_intent.payment_id,
merchant_id,
platform.get_processor().get_account().storage_scheme,
)
.await?;
let billing_address = helpers::get_address_by_id(
state,
payment_intent.billing_address_id.clone(),
platform.get_processor().get_key_store(),
&payment_intent.payment_id,
merchant_id,
platform.get_processor().get_account().storage_scheme,
)
.await?;
let payment_method_billing = helpers::get_address_by_id(
state,
payment_attempt.payment_method_billing_address_id.clone(),
platform.get_processor().get_key_store(),
&payment_intent.payment_id,
merchant_id,
platform.get_processor().get_account().storage_scheme,
)
.await?;
let currency = payment_attempt.currency.get_required_value("currency")?;
let amount = payment_attempt.get_total_amount().into();
payment_attempt
.cancellation_reason
.clone_from(&request.cancellation_reason);
let profile_id = payment_intent
.profile_id
.as_ref()
.get_required_value("profile_id")
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("'profile_id' not set in payment intent")?;
let business_profile = db
.find_business_profile_by_profile_id(
platform.get_processor().get_key_store(),
profile_id,
)
.await
.to_not_found_response(errors::ApiErrorResponse::ProfileNotFound {
id: profile_id.get_string_repr().to_owned(),
})?;
let payment_data = PaymentData {
flow: PhantomData,
payment_intent,
payment_attempt,
currency,
amount,
email: None,
mandate_id: None,
mandate_connector: None,
setup_mandate: None,
customer_acceptance: None,
token: None,
token_data: None,
address: core_types::PaymentAddress::new(
shipping_address.as_ref().map(From::from),
billing_address.as_ref().map(From::from),
payment_method_billing.as_ref().map(From::from),
business_profile.use_billing_as_payment_method_billing,
),
confirm: None,
payment_method_data: None,
payment_method_token: None,
payment_method_info: None,
force_sync: None,
all_keys_required: None,
refunds: vec![],
disputes: vec![],
attempts: None,
sessions_token: vec![],
card_cvc: None,
creds_identifier: None,
pm_token: None,
connector_customer_id: None,
recurring_mandate_payment_data: None,
multiple_capture_data: None,
redirect_response: None,
surcharge_details: None,
frm_message: None,
payment_link_data: None,
incremental_authorization_details: None,
authorizations: vec![],
authentication: None,
recurring_details: None,
poll_config: None,
tax_data: None,
session_id: None,
service_details: None,
card_testing_guard_data: None,
vault_operation: None,
threeds_method_comp_ind: None,
whole_connector_response: None,
is_manual_retry_enabled: None,
is_l2_l3_enabled: false,
external_authentication_data: None,
};
let get_trackers_response = operations::GetTrackerResponse {
operation: Box::new(self),
customer_details: None,
payment_data,
business_profile,
mandate_type: None,
};
Ok(get_trackers_response)
}
}
#[async_trait]
impl<F: Clone + Send + Sync> Domain<F, api::PaymentsCancelPostCaptureRequest, PaymentData<F>>
for PaymentCancelPostCapture
{
#[instrument(skip_all)]
async fn populate_raw_customer_details<'a>(
&'a self,
_state: &SessionState,
_payment_data: &mut PaymentData<F>,
_request: Option<&payments::CustomerDetails>,
_processor: &domain::Processor,
) -> errors::CustomResult<(), errors::StorageError> {
Ok(())
}
#[instrument(skip_all)]
async fn get_or_create_customer_details<'a>(
&'a self,
_state: &SessionState,
_payment_data: &mut PaymentData<F>,
_request: Option<payments::CustomerDetails>,
_provider: &domain::Provider,
) -> errors::CustomResult<
(
PaymentCancelPostCaptureOperation<'a, F>,
Option<domain::Customer>,
),
errors::StorageError,
> {
Ok((Box::new(self), None))
}
#[instrument(skip_all)]
async fn make_pm_data<'a>(
&'a self,
_state: &'a SessionState,
_payment_data: &mut PaymentData<F>,
_storage_scheme: enums::MerchantStorageScheme,
_merchant_key_store: &domain::MerchantKeyStore,
_customer: &Option<domain::Customer>,
_business_profile: &domain::Profile,
_should_retry_with_pan: bool,
) -> RouterResult<(
PaymentCancelPostCaptureOperation<'a, F>,
Option<domain::PaymentMethodData>,
Option<String>,
)> {
Ok((Box::new(self), None, None))
}
async fn get_connector<'a>(
&'a self,
_platform: &domain::Platform,
state: &SessionState,
_request: &api::PaymentsCancelPostCaptureRequest,
_payment_intent: &storage::PaymentIntent,
) -> errors::CustomResult<api::ConnectorChoice, errors::ApiErrorResponse> {
helpers::get_connector_default(state, None).await
}
#[instrument(skip_all)]
async fn guard_payment_against_blocklist<'a>(
&'a self,
_state: &SessionState,
_platform: &domain::Platform,
_payment_data: &mut PaymentData<F>,
) -> errors::CustomResult<bool, errors::ApiErrorResponse> {
Ok(false)
}
}
#[async_trait]
impl<F: Clone + Sync> UpdateTracker<F, PaymentData<F>, api::PaymentsCancelPostCaptureRequest>
for PaymentCancelPostCapture
{
#[instrument(skip_all)]
async fn update_trackers<'b>(
&'b self,
_state: &'b SessionState,
_req_state: ReqState,
_processor: &domain::Processor,
payment_data: PaymentData<F>,
_customer: Option<domain::Customer>,
_frm_suggestion: Option<FrmSuggestion>,
_header_payload: hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<(PaymentCancelPostCaptureOperation<'b, F>, PaymentData<F>)>
where
F: 'b + Send,
{
Ok((Box::new(self), payment_data))
}
}
impl<F: Send + Clone + Sync>
ValidateRequest<F, api::PaymentsCancelPostCaptureRequest, PaymentData<F>>
for PaymentCancelPostCapture
{
#[instrument(skip_all)]
fn validate_request<'a, 'b>(
&'b self,
request: &api::PaymentsCancelPostCaptureRequest,
processor: &'a domain::Processor,
) -> RouterResult<(
PaymentCancelPostCaptureOperation<'b, F>,
operations::ValidateResult,
)> {
Ok((
Box::new(self),
operations::ValidateResult {
merchant_id: processor.get_account().get_id().to_owned(),
payment_id: api::PaymentIdType::PaymentIntentId(request.payment_id.to_owned()),
storage_scheme: processor.get_account().storage_scheme,
requeue: false,
},
))
}
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/payments/operations/payment_session_intent.rs | crates/router/src/core/payments/operations/payment_session_intent.rs | use std::{collections::HashMap, marker::PhantomData};
use api_models::payments::PaymentsSessionRequest;
use async_trait::async_trait;
use common_utils::{errors::CustomResult, ext_traits::Encode};
use error_stack::ResultExt;
use hyperswitch_domain_models::customer;
use router_env::{instrument, logger, tracing};
use super::{BoxedOperation, Domain, GetTracker, Operation, UpdateTracker, ValidateRequest};
use crate::{
core::{
errors::{self, RouterResult, StorageErrorExt},
payments::{self, helpers, operations, operations::ValidateStatusForOperation},
},
routes::{app::ReqState, SessionState},
types::{api, domain, storage, storage::enums},
utils::ext_traits::OptionExt,
};
#[derive(Debug, Clone, Copy)]
pub struct PaymentSessionIntent;
type PaymentSessionOperation<'b, F> =
BoxedOperation<'b, F, PaymentsSessionRequest, payments::PaymentIntentData<F>>;
impl ValidateStatusForOperation for PaymentSessionIntent {
/// Validate if the current operation can be performed on the current status of the payment intent
fn validate_status_for_operation(
&self,
intent_status: common_enums::IntentStatus,
) -> Result<(), errors::ApiErrorResponse> {
match intent_status {
common_enums::IntentStatus::RequiresPaymentMethod => Ok(()),
common_enums::IntentStatus::Cancelled
| common_enums::IntentStatus::CancelledPostCapture
| common_enums::IntentStatus::Processing
| common_enums::IntentStatus::PartiallyCapturedAndProcessing
| common_enums::IntentStatus::RequiresCustomerAction
| common_enums::IntentStatus::RequiresMerchantAction
| common_enums::IntentStatus::RequiresCapture
| common_enums::IntentStatus::PartiallyAuthorizedAndRequiresCapture
| common_enums::IntentStatus::PartiallyCaptured
| common_enums::IntentStatus::RequiresConfirmation
| common_enums::IntentStatus::PartiallyCapturedAndCapturable
| common_enums::IntentStatus::Succeeded
| common_enums::IntentStatus::Failed | common_enums::IntentStatus::Conflicted | common_enums::IntentStatus::Expired => {
Err(errors::ApiErrorResponse::PreconditionFailed {
message: format!(
"You cannot create session token for this payment because it has status {intent_status}. Expected status is requires_payment_method.",
),
})
}
}
}
}
impl<F: Send + Clone + Sync> Operation<F, PaymentsSessionRequest> for &PaymentSessionIntent {
type Data = payments::PaymentIntentData<F>;
fn to_validate_request(
&self,
) -> RouterResult<&(dyn ValidateRequest<F, PaymentsSessionRequest, Self::Data> + Send + Sync)>
{
Ok(*self)
}
fn to_get_tracker(
&self,
) -> RouterResult<&(dyn GetTracker<F, Self::Data, PaymentsSessionRequest> + Send + Sync)> {
Ok(*self)
}
fn to_domain(&self) -> RouterResult<&(dyn Domain<F, PaymentsSessionRequest, Self::Data>)> {
Ok(*self)
}
fn to_update_tracker(
&self,
) -> RouterResult<
&(dyn UpdateTracker<F, payments::PaymentIntentData<F>, PaymentsSessionRequest>
+ Send
+ Sync),
> {
Ok(*self)
}
}
impl<F: Send + Clone + Sync> Operation<F, PaymentsSessionRequest> for PaymentSessionIntent {
type Data = payments::PaymentIntentData<F>;
fn to_validate_request(
&self,
) -> RouterResult<&(dyn ValidateRequest<F, PaymentsSessionRequest, Self::Data> + Send + Sync)>
{
Ok(self)
}
fn to_get_tracker(
&self,
) -> RouterResult<&(dyn GetTracker<F, Self::Data, PaymentsSessionRequest> + Send + Sync)> {
Ok(self)
}
fn to_domain(&self) -> RouterResult<&dyn Domain<F, PaymentsSessionRequest, Self::Data>> {
Ok(self)
}
fn to_update_tracker(
&self,
) -> RouterResult<
&(dyn UpdateTracker<F, payments::PaymentIntentData<F>, PaymentsSessionRequest>
+ Send
+ Sync),
> {
Ok(self)
}
}
type PaymentsCreateIntentOperation<'b, F> =
BoxedOperation<'b, F, PaymentsSessionRequest, payments::PaymentIntentData<F>>;
#[async_trait]
impl<F: Send + Clone + Sync> GetTracker<F, payments::PaymentIntentData<F>, PaymentsSessionRequest>
for PaymentSessionIntent
{
#[instrument(skip_all)]
async fn get_trackers<'a>(
&'a self,
state: &'a SessionState,
payment_id: &common_utils::id_type::GlobalPaymentId,
_request: &PaymentsSessionRequest,
platform: &domain::Platform,
_profile: &domain::Profile,
header_payload: &hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<operations::GetTrackerResponse<payments::PaymentIntentData<F>>> {
let db = &*state.store;
let storage_scheme = platform.get_processor().get_account().storage_scheme;
let payment_intent = db
.find_payment_intent_by_id(
payment_id,
platform.get_processor().get_key_store(),
storage_scheme,
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
// TODO (#7195): Add platform merchant account validation once publishable key auth is solved
self.validate_status_for_operation(payment_intent.status)?;
let payment_data = payments::PaymentIntentData {
flow: PhantomData,
payment_intent,
client_secret: None,
sessions_token: vec![],
vault_session_details: None,
connector_customer_id: None,
};
let get_trackers_response = operations::GetTrackerResponse { payment_data };
Ok(get_trackers_response)
}
}
#[async_trait]
impl<F: Clone + Sync> UpdateTracker<F, payments::PaymentIntentData<F>, PaymentsSessionRequest>
for PaymentSessionIntent
{
#[instrument(skip_all)]
async fn update_trackers<'b>(
&'b self,
state: &'b SessionState,
_req_state: ReqState,
processor: &domain::Processor,
mut payment_data: payments::PaymentIntentData<F>,
customer: Option<domain::Customer>,
_frm_suggestion: Option<common_enums::FrmSuggestion>,
_header_payload: hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<(
PaymentSessionOperation<'b, F>,
payments::PaymentIntentData<F>,
)>
where
F: 'b + Send,
{
let storage_scheme = processor.get_account().storage_scheme;
let key_store = processor.get_key_store();
let prerouting_algorithm = payment_data.payment_intent.prerouting_algorithm.clone();
payment_data.payment_intent = match prerouting_algorithm {
Some(prerouting_algorithm) => state
.store
.update_payment_intent(
payment_data.payment_intent,
storage::PaymentIntentUpdate::SessionIntentUpdate {
prerouting_algorithm,
updated_by: storage_scheme.to_string(),
},
key_store,
storage_scheme,
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?,
None => payment_data.payment_intent,
};
Ok((Box::new(self), payment_data))
}
}
impl<F: Send + Clone> ValidateRequest<F, PaymentsSessionRequest, payments::PaymentIntentData<F>>
for PaymentSessionIntent
{
#[instrument(skip_all)]
fn validate_request<'a, 'b>(
&'b self,
_request: &PaymentsSessionRequest,
platform: &'a domain::Platform,
) -> RouterResult<operations::ValidateResult> {
Ok(operations::ValidateResult {
merchant_id: platform.get_processor().get_account().get_id().to_owned(),
storage_scheme: platform.get_processor().get_account().storage_scheme,
requeue: false,
})
}
}
#[async_trait]
impl<F: Clone + Send + Sync> Domain<F, PaymentsSessionRequest, payments::PaymentIntentData<F>>
for PaymentSessionIntent
{
#[instrument(skip_all)]
async fn get_customer_details<'a>(
&'a self,
state: &SessionState,
payment_data: &mut payments::PaymentIntentData<F>,
merchant_key_store: &domain::MerchantKeyStore,
storage_scheme: enums::MerchantStorageScheme,
) -> CustomResult<
(
BoxedOperation<'a, F, PaymentsSessionRequest, payments::PaymentIntentData<F>>,
Option<domain::Customer>,
),
errors::StorageError,
> {
match payment_data.payment_intent.customer_id.clone() {
Some(id) => {
let customer = state
.store
.find_customer_by_global_id(&id, merchant_key_store, storage_scheme)
.await?;
Ok((Box::new(self), Some(customer)))
}
None => Ok((Box::new(self), None)),
}
}
#[instrument(skip_all)]
async fn make_pm_data<'a>(
&'a self,
_state: &'a SessionState,
_payment_data: &mut payments::PaymentIntentData<F>,
_storage_scheme: enums::MerchantStorageScheme,
_merchant_key_store: &domain::MerchantKeyStore,
_customer: &Option<domain::Customer>,
_business_profile: &domain::Profile,
_should_retry_with_pan: bool,
) -> RouterResult<(
PaymentsCreateIntentOperation<'a, F>,
Option<domain::PaymentMethodData>,
Option<String>,
)> {
Ok((Box::new(self), None, None))
}
async fn perform_routing<'a>(
&'a self,
platform: &domain::Platform,
business_profile: &domain::Profile,
state: &SessionState,
payment_data: &mut payments::PaymentIntentData<F>,
) -> CustomResult<api::ConnectorCallType, errors::ApiErrorResponse> {
let db = &state.store;
let all_connector_accounts = db
.find_merchant_connector_account_by_merchant_id_and_disabled_list(
platform.get_processor().get_account().get_id(),
false,
platform.get_processor().get_key_store(),
)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Database error when querying for merchant connector accounts")?;
let profile_id = business_profile.get_id();
let filtered_connector_accounts = all_connector_accounts
.filter_based_on_profile_and_connector_type(
profile_id,
common_enums::ConnectorType::PaymentProcessor,
);
let connector_and_supporting_payment_method_type = filtered_connector_accounts
.get_connector_and_supporting_payment_method_type_for_session_call();
let session_connector_data: api::SessionConnectorDatas =
connector_and_supporting_payment_method_type
.into_iter()
.filter_map(
|(merchant_connector_account, payment_method_type, payment_method)| {
match helpers::get_connector_data_with_token(
state,
merchant_connector_account.connector_name.to_string(),
Some(merchant_connector_account.get_id()),
payment_method_type,
) {
Ok(connector_data) => Some(api::SessionConnectorData::new(
payment_method_type,
connector_data,
None,
payment_method,
)),
Err(err) => {
logger::error!(session_token_error=?err);
None
}
}
},
)
.collect();
let session_token_routing_result = payments::perform_session_token_routing(
state.clone(),
business_profile,
platform.clone(),
payment_data,
session_connector_data,
)
.await?;
let pre_routing = storage::PaymentRoutingInfo {
algorithm: None,
pre_routing_results: Some((|| {
let mut pre_routing_results: HashMap<
common_enums::PaymentMethodType,
storage::PreRoutingConnectorChoice,
> = HashMap::new();
for (pm_type, routing_choice) in session_token_routing_result.routing_result {
let mut routable_choice_list = vec![];
for choice in routing_choice {
let routable_choice = api::routing::RoutableConnectorChoice {
choice_kind: api::routing::RoutableChoiceKind::FullStruct,
connector: choice
.connector
.connector_name
.to_string()
.parse::<euclid::enums::RoutableConnectors>()
.change_context(errors::ApiErrorResponse::InternalServerError)?,
merchant_connector_id: choice.connector.merchant_connector_id.clone(),
};
routable_choice_list.push(routable_choice);
}
pre_routing_results.insert(
pm_type,
storage::PreRoutingConnectorChoice::Multiple(routable_choice_list),
);
}
Ok::<_, error_stack::Report<errors::ApiErrorResponse>>(pre_routing_results)
})()?),
};
// Store the routing results in payment intent
payment_data.payment_intent.prerouting_algorithm = Some(pre_routing);
Ok(api::ConnectorCallType::SessionMultiple(
session_token_routing_result.final_result,
))
}
#[instrument(skip_all)]
async fn guard_payment_against_blocklist<'a>(
&'a self,
_state: &SessionState,
_platform: &domain::Platform,
_payment_data: &mut payments::PaymentIntentData<F>,
) -> CustomResult<bool, errors::ApiErrorResponse> {
Ok(false)
}
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/payments/operations/payment_attempt_list.rs | crates/router/src/core/payments/operations/payment_attempt_list.rs | use std::marker::PhantomData;
#[cfg(feature = "v2")]
use api_models::{enums::FrmSuggestion, payments::PaymentAttemptListRequest};
use async_trait::async_trait;
use common_utils::errors::CustomResult;
use router_env::{instrument, tracing};
use super::{BoxedOperation, Domain, GetTracker, Operation, UpdateTracker, ValidateRequest};
use crate::{
core::{
errors::{self, RouterResult},
payments::{self, operations},
},
db::errors::StorageErrorExt,
routes::{app::ReqState, SessionState},
types::{
api, domain,
storage::{self, enums},
},
};
#[derive(Debug, Clone, Copy)]
pub struct PaymentGetListAttempts;
impl<F: Send + Clone + Sync> Operation<F, PaymentAttemptListRequest> for &PaymentGetListAttempts {
type Data = payments::PaymentAttemptListData<F>;
fn to_validate_request(
&self,
) -> RouterResult<&(dyn ValidateRequest<F, PaymentAttemptListRequest, Self::Data> + Send + Sync)>
{
Ok(*self)
}
fn to_get_tracker(
&self,
) -> RouterResult<&(dyn GetTracker<F, Self::Data, PaymentAttemptListRequest> + Send + Sync)>
{
Ok(*self)
}
fn to_domain(&self) -> RouterResult<&(dyn Domain<F, PaymentAttemptListRequest, Self::Data>)> {
Ok(*self)
}
fn to_update_tracker(
&self,
) -> RouterResult<&(dyn UpdateTracker<F, Self::Data, PaymentAttemptListRequest> + Send + Sync)>
{
Ok(*self)
}
}
impl<F: Send + Clone + Sync> Operation<F, PaymentAttemptListRequest> for PaymentGetListAttempts {
type Data = payments::PaymentAttemptListData<F>;
fn to_validate_request(
&self,
) -> RouterResult<&(dyn ValidateRequest<F, PaymentAttemptListRequest, Self::Data> + Send + Sync)>
{
Ok(self)
}
fn to_get_tracker(
&self,
) -> RouterResult<&(dyn GetTracker<F, Self::Data, PaymentAttemptListRequest> + Send + Sync)>
{
Ok(self)
}
fn to_domain(&self) -> RouterResult<&(dyn Domain<F, PaymentAttemptListRequest, Self::Data>)> {
Ok(self)
}
fn to_update_tracker(
&self,
) -> RouterResult<&(dyn UpdateTracker<F, Self::Data, PaymentAttemptListRequest> + Send + Sync)>
{
Ok(self)
}
}
type PaymentAttemptsListOperation<'b, F> =
BoxedOperation<'b, F, PaymentAttemptListRequest, payments::PaymentAttemptListData<F>>;
#[async_trait]
impl<F: Send + Clone + Sync>
GetTracker<F, payments::PaymentAttemptListData<F>, PaymentAttemptListRequest>
for PaymentGetListAttempts
{
#[instrument(skip_all)]
async fn get_trackers<'a>(
&'a self,
state: &'a SessionState,
_payment_id: &common_utils::id_type::GlobalPaymentId,
request: &PaymentAttemptListRequest,
platform: &domain::Platform,
_profile: &domain::Profile,
_header_payload: &hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<operations::GetTrackerResponse<payments::PaymentAttemptListData<F>>> {
let db = &*state.store;
let storage_scheme = platform.get_processor().get_account().storage_scheme;
let payment_attempt_list = db
.find_payment_attempts_by_payment_intent_id(
&request.payment_intent_id,
platform.get_processor().get_key_store(),
storage_scheme,
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
let payment_data = payments::PaymentAttemptListData {
flow: PhantomData,
payment_attempt_list,
};
let get_trackers_response = operations::GetTrackerResponse { payment_data };
Ok(get_trackers_response)
}
}
#[async_trait]
impl<F: Clone + Sync>
UpdateTracker<F, payments::PaymentAttemptListData<F>, PaymentAttemptListRequest>
for PaymentGetListAttempts
{
#[instrument(skip_all)]
async fn update_trackers<'b>(
&'b self,
_state: &'b SessionState,
_req_state: ReqState,
_processor: &domain::Processor,
payment_data: payments::PaymentAttemptListData<F>,
_customer: Option<domain::Customer>,
_frm_suggestion: Option<FrmSuggestion>,
_header_payload: hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<(
PaymentAttemptsListOperation<'b, F>,
payments::PaymentAttemptListData<F>,
)>
where
F: 'b + Send,
{
Ok((Box::new(self), payment_data))
}
}
impl<F: Send + Clone + Sync>
ValidateRequest<F, PaymentAttemptListRequest, payments::PaymentAttemptListData<F>>
for PaymentGetListAttempts
{
#[instrument(skip_all)]
fn validate_request<'a, 'b>(
&'b self,
_request: &PaymentAttemptListRequest,
platform: &'a domain::Platform,
) -> RouterResult<operations::ValidateResult> {
Ok(operations::ValidateResult {
merchant_id: platform.get_processor().get_account().get_id().to_owned(),
storage_scheme: platform.get_processor().get_account().storage_scheme,
requeue: false,
})
}
}
#[async_trait]
impl<F: Clone + Send + Sync>
Domain<F, PaymentAttemptListRequest, payments::PaymentAttemptListData<F>>
for PaymentGetListAttempts
{
#[instrument(skip_all)]
async fn get_customer_details<'a>(
&'a self,
_state: &SessionState,
_payment_data: &mut payments::PaymentAttemptListData<F>,
_merchant_key_store: &domain::MerchantKeyStore,
_storage_scheme: enums::MerchantStorageScheme,
) -> CustomResult<
(
BoxedOperation<'a, F, PaymentAttemptListRequest, payments::PaymentAttemptListData<F>>,
Option<domain::Customer>,
),
errors::StorageError,
> {
Ok((Box::new(self), None))
}
#[instrument(skip_all)]
async fn make_pm_data<'a>(
&'a self,
_state: &'a SessionState,
_payment_data: &mut payments::PaymentAttemptListData<F>,
_storage_scheme: enums::MerchantStorageScheme,
_merchant_key_store: &domain::MerchantKeyStore,
_customer: &Option<domain::Customer>,
_business_profile: &domain::Profile,
_should_retry_with_pan: bool,
) -> RouterResult<(
PaymentAttemptsListOperation<'a, F>,
Option<domain::PaymentMethodData>,
Option<String>,
)> {
Ok((Box::new(self), None, None))
}
#[instrument(skip_all)]
async fn perform_routing<'a>(
&'a self,
_platform: &domain::Platform,
_business_profile: &domain::Profile,
_state: &SessionState,
_payment_data: &mut payments::PaymentAttemptListData<F>,
) -> CustomResult<api::ConnectorCallType, errors::ApiErrorResponse> {
Ok(api::ConnectorCallType::Skip)
}
#[instrument(skip_all)]
async fn guard_payment_against_blocklist<'a>(
&'a self,
_state: &SessionState,
_platform: &domain::Platform,
_payment_data: &mut payments::PaymentAttemptListData<F>,
) -> CustomResult<bool, errors::ApiErrorResponse> {
Ok(false)
}
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/user_role/role.rs | crates/router/src/core/user_role/role.rs | use std::{cmp, collections::HashSet, ops::Not};
use api_models::user_role::role as role_api;
use common_enums::{EntityType, ParentGroup, PermissionGroup};
use common_utils::generate_id_with_default_len;
use diesel_models::role::{ListRolesByEntityPayload, RoleNew, RoleUpdate};
use error_stack::{report, ResultExt};
use crate::{
core::errors::{StorageErrorExt, UserErrors, UserResponse},
routes::{app::ReqState, SessionState},
services::{
authentication::{blacklist, UserFromToken},
authorization::{
permission_groups::{ParentGroupExt, PermissionGroupExt},
roles::{self, predefined_roles::PREDEFINED_ROLES},
},
ApplicationResponse,
},
types::domain::user::RoleName,
utils,
};
pub async fn get_role_from_token_with_groups(
state: SessionState,
user_from_token: UserFromToken,
) -> UserResponse<Vec<PermissionGroup>> {
let role_info = user_from_token
.get_role_info_from_db(&state)
.await
.attach_printable("Invalid role_id in JWT")?;
let permissions = role_info.get_permission_groups().to_vec();
Ok(ApplicationResponse::Json(permissions))
}
pub async fn get_groups_and_resources_for_role_from_token(
state: SessionState,
user_from_token: UserFromToken,
) -> UserResponse<role_api::GroupsAndResources> {
let role_info = user_from_token.get_role_info_from_db(&state).await?;
let groups = role_info
.get_permission_groups()
.into_iter()
.collect::<Vec<_>>();
let resources = groups
.iter()
.flat_map(|group| group.resources())
.collect::<HashSet<_>>()
.into_iter()
.collect();
Ok(ApplicationResponse::Json(role_api::GroupsAndResources {
groups,
resources,
}))
}
pub async fn get_parent_groups_info_for_role_from_token(
state: SessionState,
user_from_token: UserFromToken,
) -> UserResponse<Vec<role_api::ParentGroupInfo>> {
let role_info = user_from_token.get_role_info_from_db(&state).await?;
let groups = role_info
.get_permission_groups()
.into_iter()
.collect::<Vec<_>>();
let parent_groups = utils::user_role::permission_groups_to_parent_group_info(
&groups,
role_info.get_entity_type(),
);
Ok(ApplicationResponse::Json(parent_groups))
}
pub async fn create_role(
state: SessionState,
user_from_token: UserFromToken,
req: role_api::CreateRoleRequest,
_req_state: ReqState,
) -> UserResponse<role_api::RoleInfoWithGroupsResponse> {
let now = common_utils::date_time::now();
let user_entity_type = user_from_token
.get_role_info_from_db(&state)
.await
.attach_printable("Invalid role_id in JWT")?
.get_entity_type();
let role_entity_type = req.entity_type.unwrap_or(EntityType::Merchant);
if matches!(role_entity_type, EntityType::Organization) {
return Err(report!(UserErrors::InvalidRoleOperation))
.attach_printable("User trying to create org level custom role");
}
let requestor_entity_from_role_scope = EntityType::from(req.role_scope);
if requestor_entity_from_role_scope < role_entity_type {
return Err(report!(UserErrors::InvalidRoleOperation)).attach_printable(format!(
"User is trying to create role of type {role_entity_type} and scope {requestor_entity_from_role_scope}",
));
}
let max_from_scope_and_entity = cmp::max(requestor_entity_from_role_scope, role_entity_type);
if user_entity_type < max_from_scope_and_entity {
return Err(report!(UserErrors::InvalidRoleOperation)).attach_printable(format!(
"{user_entity_type} is trying to create of scope {requestor_entity_from_role_scope} and of type {role_entity_type}",
));
}
let role_name = RoleName::new(req.role_name)?;
utils::user_role::validate_role_groups(&req.groups)?;
utils::user_role::validate_role_name(
&state,
&role_name,
&user_from_token.merchant_id,
&user_from_token.org_id,
user_from_token
.tenant_id
.as_ref()
.unwrap_or(&state.tenant.tenant_id),
&user_from_token.profile_id,
&role_entity_type,
)
.await?;
let (org_id, merchant_id, profile_id) = match role_entity_type {
EntityType::Organization | EntityType::Tenant => (user_from_token.org_id, None, None),
EntityType::Merchant => (
user_from_token.org_id,
Some(user_from_token.merchant_id),
None,
),
EntityType::Profile => (
user_from_token.org_id,
Some(user_from_token.merchant_id),
Some(user_from_token.profile_id),
),
};
let role = state
.global_store
.insert_role(RoleNew {
role_id: generate_id_with_default_len("role"),
role_name: role_name.get_role_name(),
merchant_id,
org_id,
groups: req.groups,
scope: req.role_scope,
entity_type: role_entity_type,
created_by: user_from_token.user_id.clone(),
last_modified_by: user_from_token.user_id,
created_at: now,
last_modified_at: now,
profile_id,
tenant_id: user_from_token.tenant_id.unwrap_or(state.tenant.tenant_id),
})
.await
.to_duplicate_response(UserErrors::RoleNameAlreadyExists)?;
Ok(ApplicationResponse::Json(
role_api::RoleInfoWithGroupsResponse {
groups: role.groups,
role_id: role.role_id,
role_name: role.role_name,
role_scope: role.scope,
entity_type: role.entity_type,
},
))
}
pub async fn create_role_v2(
state: SessionState,
user_from_token: UserFromToken,
req: role_api::CreateRoleV2Request,
_req_state: ReqState,
) -> UserResponse<role_api::RoleInfoResponseWithParentsGroup> {
let now = common_utils::date_time::now();
let user_entity_type = user_from_token
.get_role_info_from_db(&state)
.await
.attach_printable("Invalid role_id in JWT")?
.get_entity_type();
let role_entity_type = req.entity_type.unwrap_or(EntityType::Merchant);
if matches!(role_entity_type, EntityType::Organization) {
return Err(report!(UserErrors::InvalidRoleOperation))
.attach_printable("User trying to create org level custom role");
}
let requestor_entity_from_role_scope = EntityType::from(req.role_scope);
if requestor_entity_from_role_scope < role_entity_type {
return Err(report!(UserErrors::InvalidRoleOperation)).attach_printable(format!(
"User is trying to create role of type {role_entity_type} and scope {requestor_entity_from_role_scope}",
));
}
let max_from_scope_and_entity = cmp::max(requestor_entity_from_role_scope, role_entity_type);
if user_entity_type < max_from_scope_and_entity {
return Err(report!(UserErrors::InvalidRoleOperation)).attach_printable(format!(
"{user_entity_type} is trying to create of scope {requestor_entity_from_role_scope} and of type {role_entity_type}",
));
}
let role_name = RoleName::new(req.role_name.clone())?;
let permission_groups =
utils::user_role::parent_group_info_request_to_permission_groups(&req.parent_groups)?;
utils::user_role::validate_role_groups(&permission_groups)?;
utils::user_role::validate_role_name(
&state,
&role_name,
&user_from_token.merchant_id,
&user_from_token.org_id,
user_from_token
.tenant_id
.as_ref()
.unwrap_or(&state.tenant.tenant_id),
&user_from_token.profile_id,
&role_entity_type,
)
.await?;
let (org_id, merchant_id, profile_id) = match role_entity_type {
EntityType::Organization | EntityType::Tenant => (user_from_token.org_id, None, None),
EntityType::Merchant => (
user_from_token.org_id,
Some(user_from_token.merchant_id),
None,
),
EntityType::Profile => (
user_from_token.org_id,
Some(user_from_token.merchant_id),
Some(user_from_token.profile_id),
),
};
let role = state
.global_store
.insert_role(RoleNew {
role_id: generate_id_with_default_len("role"),
role_name: role_name.get_role_name(),
merchant_id,
org_id,
groups: permission_groups,
scope: req.role_scope,
entity_type: role_entity_type,
created_by: user_from_token.user_id.clone(),
last_modified_by: user_from_token.user_id,
created_at: now,
last_modified_at: now,
profile_id,
tenant_id: user_from_token.tenant_id.unwrap_or(state.tenant.tenant_id),
})
.await
.to_duplicate_response(UserErrors::RoleNameAlreadyExists)?;
let parent_group_details =
utils::user_role::permission_groups_to_parent_group_info(&role.groups, role.entity_type);
let parent_group_descriptions: Vec<role_api::ParentGroupDescription> = parent_group_details
.into_iter()
.filter_map(|group_details| {
let description = utils::user_role::resources_to_description(
group_details.resources,
role.entity_type,
)?;
Some(role_api::ParentGroupDescription {
name: group_details.name,
description,
scopes: group_details.scopes,
})
})
.collect();
Ok(ApplicationResponse::Json(
role_api::RoleInfoResponseWithParentsGroup {
role_id: role.role_id,
role_name: role.role_name,
role_scope: role.scope,
entity_type: role.entity_type,
parent_groups: parent_group_descriptions,
},
))
}
pub async fn get_role_with_groups(
state: SessionState,
user_from_token: UserFromToken,
role: role_api::GetRoleRequest,
) -> UserResponse<role_api::RoleInfoWithGroupsResponse> {
let role_info = roles::RoleInfo::from_role_id_org_id_tenant_id(
&state,
&role.role_id,
&user_from_token.org_id,
user_from_token
.tenant_id
.as_ref()
.unwrap_or(&state.tenant.tenant_id),
)
.await
.to_not_found_response(UserErrors::InvalidRoleId)?;
if role_info.is_internal() {
return Err(UserErrors::InvalidRoleId.into());
}
Ok(ApplicationResponse::Json(
role_api::RoleInfoWithGroupsResponse {
groups: role_info.get_permission_groups().to_vec(),
role_id: role.role_id,
role_name: role_info.get_role_name().to_string(),
role_scope: role_info.get_scope(),
entity_type: role_info.get_entity_type(),
},
))
}
pub async fn get_parent_info_for_role(
state: SessionState,
user_from_token: UserFromToken,
role: role_api::GetRoleRequest,
) -> UserResponse<role_api::RoleInfoWithParents> {
let role_info = roles::RoleInfo::from_role_id_org_id_tenant_id(
&state,
&role.role_id,
&user_from_token.org_id,
user_from_token
.tenant_id
.as_ref()
.unwrap_or(&state.tenant.tenant_id),
)
.await
.to_not_found_response(UserErrors::InvalidRoleId)?;
if role_info.is_internal() {
return Err(UserErrors::InvalidRoleId.into());
}
let parent_groups = ParentGroup::get_descriptions_for_groups(
role_info.get_entity_type(),
role_info.get_permission_groups().to_vec(),
)
.ok_or(UserErrors::InternalServerError)
.attach_printable(format!(
"No group descriptions found for role_id: {}",
role.role_id
))?
.into_iter()
.map(
|(parent_group, description)| role_api::ParentGroupDescription {
name: parent_group.clone(),
description,
scopes: role_info
.get_permission_groups()
.iter()
.filter_map(|group| (group.parent() == parent_group).then_some(group.scope()))
// TODO: Remove this hashset conversion when merchant access
// and organization access groups are removed
.collect::<HashSet<_>>()
.into_iter()
.collect(),
},
)
.collect();
Ok(ApplicationResponse::Json(role_api::RoleInfoWithParents {
role_id: role.role_id,
parent_groups,
role_name: role_info.get_role_name().to_string(),
role_scope: role_info.get_scope(),
}))
}
pub async fn update_role(
state: SessionState,
user_from_token: UserFromToken,
req: role_api::UpdateRoleRequest,
role_id: &str,
) -> UserResponse<role_api::RoleInfoWithGroupsResponse> {
let role_name = req.role_name.map(RoleName::new).transpose()?;
let role_info = roles::RoleInfo::from_role_id_in_lineage(
&state,
role_id,
&user_from_token.merchant_id,
&user_from_token.org_id,
&user_from_token.profile_id,
user_from_token
.tenant_id
.as_ref()
.unwrap_or(&state.tenant.tenant_id),
)
.await
.to_not_found_response(UserErrors::InvalidRoleOperation)?;
let user_role_info = user_from_token.get_role_info_from_db(&state).await?;
let requested_entity_from_role_scope = EntityType::from(role_info.get_scope());
let requested_role_entity_type = role_info.get_entity_type();
let max_from_scope_and_entity =
cmp::max(requested_entity_from_role_scope, requested_role_entity_type);
if user_role_info.get_entity_type() < max_from_scope_and_entity {
return Err(report!(UserErrors::InvalidRoleOperation)).attach_printable(format!(
"{} is trying to update of scope {} and of type {}",
user_role_info.get_entity_type(),
requested_entity_from_role_scope,
requested_role_entity_type
));
}
if let Some(ref role_name) = role_name {
utils::user_role::validate_role_name(
&state,
role_name,
&user_from_token.merchant_id,
&user_from_token.org_id,
user_from_token
.tenant_id
.as_ref()
.unwrap_or(&state.tenant.tenant_id),
&user_from_token.profile_id,
&role_info.get_entity_type(),
)
.await?;
}
if let Some(ref groups) = req.groups {
utils::user_role::validate_role_groups(groups)?;
}
let updated_role = state
.global_store
.update_role_by_role_id(
role_id,
RoleUpdate::UpdateDetails {
groups: req.groups,
role_name: role_name.map(RoleName::get_role_name),
last_modified_at: common_utils::date_time::now(),
last_modified_by: user_from_token.user_id,
},
)
.await
.to_duplicate_response(UserErrors::RoleNameAlreadyExists)?;
blacklist::insert_role_in_blacklist(&state, role_id).await?;
Ok(ApplicationResponse::Json(
role_api::RoleInfoWithGroupsResponse {
groups: updated_role.groups,
role_id: updated_role.role_id,
role_name: updated_role.role_name,
role_scope: updated_role.scope,
entity_type: updated_role.entity_type,
},
))
}
pub async fn list_roles_with_info(
state: SessionState,
user_from_token: UserFromToken,
request: role_api::ListRolesQueryParams,
) -> UserResponse<role_api::ListRolesResponse> {
let user_role_info = user_from_token
.get_role_info_from_db(&state)
.await
.attach_printable("Invalid role_id in JWT")?;
if user_role_info.is_internal() {
return Err(UserErrors::InvalidRoleOperationWithMessage(
"Internal roles are not allowed for this operation".to_string(),
)
.into());
}
let mut role_info_vec = PREDEFINED_ROLES
.values()
.filter(|role| role.is_internal().not())
.cloned()
.collect::<Vec<_>>();
let user_role_entity = user_role_info.get_entity_type();
let is_lineage_data_required = request.entity_type.is_none();
let tenant_id = user_from_token
.tenant_id
.as_ref()
.unwrap_or(&state.tenant.tenant_id)
.to_owned();
let custom_roles =
match utils::user_role::get_min_entity(user_role_entity, request.entity_type)? {
EntityType::Tenant | EntityType::Organization => state
.global_store
.generic_list_roles_by_entity_type(
ListRolesByEntityPayload::Organization,
is_lineage_data_required,
tenant_id,
user_from_token.org_id,
)
.await
.change_context(UserErrors::InternalServerError)
.attach_printable("Failed to get roles")?,
EntityType::Merchant => state
.global_store
.generic_list_roles_by_entity_type(
ListRolesByEntityPayload::Merchant(user_from_token.merchant_id),
is_lineage_data_required,
tenant_id,
user_from_token.org_id,
)
.await
.change_context(UserErrors::InternalServerError)
.attach_printable("Failed to get roles")?,
EntityType::Profile => state
.global_store
.generic_list_roles_by_entity_type(
ListRolesByEntityPayload::Profile(
user_from_token.merchant_id,
user_from_token.profile_id,
),
is_lineage_data_required,
tenant_id,
user_from_token.org_id,
)
.await
.change_context(UserErrors::InternalServerError)
.attach_printable("Failed to get roles")?,
};
role_info_vec.extend(custom_roles.into_iter().map(roles::RoleInfo::from));
if request.groups == Some(true) {
let list_role_info_response = role_info_vec
.into_iter()
.filter_map(|role_info| {
let is_lower_entity = user_role_entity >= role_info.get_entity_type();
let request_filter = request
.entity_type
.is_none_or(|entity_type| entity_type == role_info.get_entity_type());
(is_lower_entity && request_filter).then_some({
let permission_groups = role_info.get_permission_groups();
let parent_group_details =
utils::user_role::permission_groups_to_parent_group_info(
&permission_groups,
role_info.get_entity_type(),
);
let parent_group_descriptions: Vec<role_api::ParentGroupDescription> =
parent_group_details
.into_iter()
.filter_map(|group_details| {
let description = utils::user_role::resources_to_description(
group_details.resources,
role_info.get_entity_type(),
)?;
Some(role_api::ParentGroupDescription {
name: group_details.name,
description,
scopes: group_details.scopes,
})
})
.collect();
role_api::RoleInfoResponseWithParentsGroup {
role_id: role_info.get_role_id().to_string(),
role_name: role_info.get_role_name().to_string(),
entity_type: role_info.get_entity_type(),
parent_groups: parent_group_descriptions,
role_scope: role_info.get_scope(),
}
})
})
.collect::<Vec<_>>();
Ok(ApplicationResponse::Json(
role_api::ListRolesResponse::WithParentGroups(list_role_info_response),
))
}
// TODO: To be deprecated
else {
let list_role_info_response = role_info_vec
.into_iter()
.filter_map(|role_info| {
let is_lower_entity = user_role_entity >= role_info.get_entity_type();
let request_filter = request
.entity_type
.is_none_or(|entity_type| entity_type == role_info.get_entity_type());
(is_lower_entity && request_filter).then_some(role_api::RoleInfoResponseNew {
role_id: role_info.get_role_id().to_string(),
role_name: role_info.get_role_name().to_string(),
groups: role_info.get_permission_groups().to_vec(),
entity_type: role_info.get_entity_type(),
scope: role_info.get_scope(),
})
})
.collect::<Vec<_>>();
Ok(ApplicationResponse::Json(
role_api::ListRolesResponse::WithGroups(list_role_info_response),
))
}
}
pub async fn list_roles_at_entity_level(
state: SessionState,
user_from_token: UserFromToken,
req: role_api::ListRolesAtEntityLevelRequest,
check_type: role_api::RoleCheckType,
) -> UserResponse<Vec<role_api::MinimalRoleInfo>> {
let user_entity_type = user_from_token
.get_role_info_from_db(&state)
.await
.attach_printable("Invalid role_id in JWT")?
.get_entity_type();
if req.entity_type > user_entity_type {
return Err(UserErrors::InvalidRoleOperationWithMessage(
"User is attempting to request list roles above the current entity level".to_string(),
)
.into());
}
let mut role_info_vec = PREDEFINED_ROLES.values().cloned().collect::<Vec<_>>();
let tenant_id = user_from_token
.tenant_id
.as_ref()
.unwrap_or(&state.tenant.tenant_id)
.to_owned();
let is_lineage_data_required = false;
let custom_roles = match req.entity_type {
EntityType::Tenant | EntityType::Organization => state
.global_store
.generic_list_roles_by_entity_type(
ListRolesByEntityPayload::Organization,
is_lineage_data_required,
tenant_id,
user_from_token.org_id,
)
.await
.change_context(UserErrors::InternalServerError)
.attach_printable("Failed to get roles")?,
EntityType::Merchant => state
.global_store
.generic_list_roles_by_entity_type(
ListRolesByEntityPayload::Merchant(user_from_token.merchant_id),
is_lineage_data_required,
tenant_id,
user_from_token.org_id,
)
.await
.change_context(UserErrors::InternalServerError)
.attach_printable("Failed to get roles")?,
EntityType::Profile => state
.global_store
.generic_list_roles_by_entity_type(
ListRolesByEntityPayload::Profile(
user_from_token.merchant_id,
user_from_token.profile_id,
),
is_lineage_data_required,
tenant_id,
user_from_token.org_id,
)
.await
.change_context(UserErrors::InternalServerError)
.attach_printable("Failed to get roles")?,
};
role_info_vec.extend(custom_roles.into_iter().map(roles::RoleInfo::from));
let list_minimal_role_info = role_info_vec
.into_iter()
.filter_map(|role_info| {
let check_type = match check_type {
role_api::RoleCheckType::Invite => role_info.is_invitable(),
role_api::RoleCheckType::Update => role_info.is_updatable(),
};
if check_type && role_info.get_entity_type() == req.entity_type {
Some(role_api::MinimalRoleInfo {
role_id: role_info.get_role_id().to_string(),
role_name: role_info.get_role_name().to_string(),
})
} else {
None
}
})
.collect::<Vec<_>>();
Ok(ApplicationResponse::Json(list_minimal_role_info))
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/blocklist/utils.rs | crates/router/src/core/blocklist/utils.rs | use api_models::blocklist as api_blocklist;
use common_enums::MerchantDecision;
use common_utils::errors::CustomResult;
use diesel_models::configs;
use error_stack::ResultExt;
use masking::StrongSecret;
use super::{errors, transformers::generate_fingerprint, SessionState};
use crate::{
consts,
core::{
errors::{RouterResult, StorageErrorExt},
payments::PaymentData,
},
logger,
types::{domain, storage, transformers::ForeignInto},
utils,
};
pub async fn delete_entry_from_blocklist(
state: &SessionState,
merchant_id: &common_utils::id_type::MerchantId,
request: api_blocklist::DeleteFromBlocklistRequest,
) -> RouterResult<api_blocklist::DeleteFromBlocklistResponse> {
let blocklist_entry = match request {
api_blocklist::DeleteFromBlocklistRequest::CardBin(bin) => {
delete_card_bin_blocklist_entry(state, &bin, merchant_id).await?
}
api_blocklist::DeleteFromBlocklistRequest::ExtendedCardBin(xbin) => {
delete_card_bin_blocklist_entry(state, &xbin, merchant_id).await?
}
api_blocklist::DeleteFromBlocklistRequest::Fingerprint(fingerprint_id) => state
.store
.delete_blocklist_entry_by_merchant_id_fingerprint_id(merchant_id, &fingerprint_id)
.await
.to_not_found_response(errors::ApiErrorResponse::GenericNotFoundError {
message: "no blocklist record for the given fingerprint id was found".to_string(),
})?,
};
Ok(blocklist_entry.foreign_into())
}
pub async fn toggle_blocklist_guard_for_merchant(
state: &SessionState,
merchant_id: &common_utils::id_type::MerchantId,
query: api_blocklist::ToggleBlocklistQuery,
) -> CustomResult<api_blocklist::ToggleBlocklistResponse, errors::ApiErrorResponse> {
let key = merchant_id.get_blocklist_guard_key();
let maybe_guard = state.store.find_config_by_key_from_db(&key).await;
let new_config = configs::ConfigNew {
key: key.clone(),
config: query.status.to_string(),
};
match maybe_guard {
Ok(_config) => {
let updated_config = configs::ConfigUpdate::Update {
config: Some(query.status.to_string()),
};
state
.store
.update_config_by_key(&key, updated_config)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Error enabling the blocklist guard")?;
}
Err(e) if e.current_context().is_db_not_found() => {
state
.store
.insert_config(new_config)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Error enabling the blocklist guard")?;
}
Err(error) => {
logger::error!(?error);
Err(error)
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Error enabling the blocklist guard")?;
}
};
let guard_status = if query.status { "enabled" } else { "disabled" };
Ok(api_blocklist::ToggleBlocklistResponse {
blocklist_guard_status: guard_status.to_string(),
})
}
pub async fn list_blocklist_entries_for_merchant(
state: &SessionState,
merchant_id: &common_utils::id_type::MerchantId,
query: api_blocklist::ListBlocklistQuery,
) -> RouterResult<Vec<api_blocklist::BlocklistResponse>> {
state
.store
.list_blocklist_entries_by_merchant_id_data_kind(
merchant_id,
query.data_kind,
query.limit.into(),
query.offset.into(),
)
.await
.to_not_found_response(errors::ApiErrorResponse::GenericNotFoundError {
message: "no blocklist records found".to_string(),
})
.map(|v| v.into_iter().map(ForeignInto::foreign_into).collect())
}
fn validate_card_bin(bin: &str) -> RouterResult<()> {
if bin.len() == 6 && bin.chars().all(|c| c.is_ascii_digit()) {
Ok(())
} else {
Err(errors::ApiErrorResponse::InvalidDataFormat {
field_name: "data".to_string(),
expected_format: "a 6 digit number".to_string(),
}
.into())
}
}
fn validate_extended_card_bin(bin: &str) -> RouterResult<()> {
if bin.len() == 8 && bin.chars().all(|c| c.is_ascii_digit()) {
Ok(())
} else {
Err(errors::ApiErrorResponse::InvalidDataFormat {
field_name: "data".to_string(),
expected_format: "an 8 digit number".to_string(),
}
.into())
}
}
pub async fn insert_entry_into_blocklist(
state: &SessionState,
merchant_id: &common_utils::id_type::MerchantId,
to_block: api_blocklist::AddToBlocklistRequest,
) -> RouterResult<api_blocklist::AddToBlocklistResponse> {
let blocklist_entry = match &to_block {
api_blocklist::AddToBlocklistRequest::CardBin(bin) => {
validate_card_bin(bin)?;
duplicate_check_insert_bin(
bin,
state,
merchant_id,
common_enums::BlocklistDataKind::CardBin,
)
.await?
}
api_blocklist::AddToBlocklistRequest::ExtendedCardBin(bin) => {
validate_extended_card_bin(bin)?;
duplicate_check_insert_bin(
bin,
state,
merchant_id,
common_enums::BlocklistDataKind::ExtendedCardBin,
)
.await?
}
api_blocklist::AddToBlocklistRequest::Fingerprint(fingerprint_id) => {
let blocklist_entry_result = state
.store
.find_blocklist_entry_by_merchant_id_fingerprint_id(merchant_id, fingerprint_id)
.await;
match blocklist_entry_result {
Ok(_) => {
return Err(errors::ApiErrorResponse::PreconditionFailed {
message: "data associated with the given fingerprint is already blocked"
.to_string(),
}
.into());
}
// if it is a db not found error, we can proceed as normal
Err(inner) if inner.current_context().is_db_not_found() => {}
err @ Err(_) => {
err.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("error fetching blocklist entry from table")?;
}
}
state
.store
.insert_blocklist_entry(storage::BlocklistNew {
merchant_id: merchant_id.to_owned(),
fingerprint_id: fingerprint_id.clone(),
data_kind: api_models::enums::enums::BlocklistDataKind::PaymentMethod,
metadata: None,
created_at: common_utils::date_time::now(),
})
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("failed to add fingerprint to blocklist")?
}
};
Ok(blocklist_entry.foreign_into())
}
pub async fn get_merchant_fingerprint_secret(
state: &SessionState,
merchant_id: &common_utils::id_type::MerchantId,
) -> RouterResult<String> {
let key = merchant_id.get_merchant_fingerprint_secret_key();
let config_fetch_result = state.store.find_config_by_key(&key).await;
match config_fetch_result {
Ok(config) => Ok(config.config),
Err(e) if e.current_context().is_db_not_found() => {
let new_fingerprint_secret =
utils::generate_id(consts::FINGERPRINT_SECRET_LENGTH, "fs");
let new_config = storage::ConfigNew {
key,
config: new_fingerprint_secret.clone(),
};
state
.store
.insert_config(new_config)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("unable to create new fingerprint secret for merchant")?;
Ok(new_fingerprint_secret)
}
Err(e) => Err(e)
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("error fetching merchant fingerprint secret"),
}
}
async fn duplicate_check_insert_bin(
bin: &str,
state: &SessionState,
merchant_id: &common_utils::id_type::MerchantId,
data_kind: common_enums::BlocklistDataKind,
) -> RouterResult<storage::Blocklist> {
let blocklist_entry_result = state
.store
.find_blocklist_entry_by_merchant_id_fingerprint_id(merchant_id, bin)
.await;
match blocklist_entry_result {
Ok(_) => {
return Err(errors::ApiErrorResponse::PreconditionFailed {
message: "provided bin is already blocked".to_string(),
}
.into());
}
Err(e) if e.current_context().is_db_not_found() => {}
err @ Err(_) => {
return err
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("unable to fetch blocklist entry");
}
}
state
.store
.insert_blocklist_entry(storage::BlocklistNew {
merchant_id: merchant_id.to_owned(),
fingerprint_id: bin.to_string(),
data_kind,
metadata: None,
created_at: common_utils::date_time::now(),
})
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("error inserting pm blocklist item")
}
async fn delete_card_bin_blocklist_entry(
state: &SessionState,
bin: &str,
merchant_id: &common_utils::id_type::MerchantId,
) -> RouterResult<storage::Blocklist> {
state
.store
.delete_blocklist_entry_by_merchant_id_fingerprint_id(merchant_id, bin)
.await
.to_not_found_response(errors::ApiErrorResponse::GenericNotFoundError {
message: "could not find a blocklist entry for the given bin".to_string(),
})
}
pub async fn should_payment_be_blocked(
state: &SessionState,
platform: &domain::Platform,
payment_method_data: &Option<domain::PaymentMethodData>,
) -> CustomResult<bool, errors::ApiErrorResponse> {
let db = &state.store;
let merchant_id = platform.get_processor().get_account().get_id();
let merchant_fingerprint_secret = get_merchant_fingerprint_secret(state, merchant_id).await?;
// Hashed Fingerprint to check whether or not this payment should be blocked.
let card_number_fingerprint =
if let Some(domain::PaymentMethodData::Card(card)) = payment_method_data {
generate_fingerprint(
state,
StrongSecret::new(card.card_number.get_card_no()),
StrongSecret::new(merchant_fingerprint_secret.clone()),
)
.await
.attach_printable("error in pm fingerprint creation")
.map_or_else(
|error| {
logger::error!(?error);
None
},
Some,
)
.map(|payload| payload.fingerprint_id)
} else {
None
};
// Hashed Cardbin to check whether or not this payment should be blocked.
let card_bin_fingerprint = payment_method_data
.as_ref()
.and_then(|pm_data| match pm_data {
domain::PaymentMethodData::Card(card) => Some(card.card_number.get_card_isin()),
_ => None,
});
// Hashed Extended Cardbin to check whether or not this payment should be blocked.
let extended_card_bin_fingerprint =
payment_method_data
.as_ref()
.and_then(|pm_data| match pm_data {
domain::PaymentMethodData::Card(card) => {
Some(card.card_number.get_extended_card_bin())
}
_ => None,
});
//validating the payment method.
let mut blocklist_futures = Vec::new();
if let Some(card_number_fingerprint) = card_number_fingerprint.as_ref() {
blocklist_futures.push(db.find_blocklist_entry_by_merchant_id_fingerprint_id(
merchant_id,
card_number_fingerprint,
));
}
if let Some(card_bin_fingerprint) = card_bin_fingerprint.as_ref() {
blocklist_futures.push(
db.find_blocklist_entry_by_merchant_id_fingerprint_id(
merchant_id,
card_bin_fingerprint,
),
);
}
if let Some(extended_card_bin_fingerprint) = extended_card_bin_fingerprint.as_ref() {
blocklist_futures.push(db.find_blocklist_entry_by_merchant_id_fingerprint_id(
merchant_id,
extended_card_bin_fingerprint,
));
}
let blocklist_lookups = futures::future::join_all(blocklist_futures).await;
let mut should_payment_be_blocked = false;
for lookup in blocklist_lookups {
match lookup {
Ok(_) => {
should_payment_be_blocked = true;
}
Err(e) => {
logger::error!(blocklist_db_error=?e, "failed db operations for blocklist");
}
}
}
Ok(should_payment_be_blocked)
}
pub async fn validate_data_for_blocklist<F>(
state: &SessionState,
platform: &domain::Platform,
payment_data: &mut PaymentData<F>,
) -> CustomResult<bool, errors::ApiErrorResponse>
where
F: Send + Clone,
{
let db = &state.store;
let should_payment_be_blocked =
should_payment_be_blocked(state, platform, &payment_data.payment_method_data).await?;
if should_payment_be_blocked {
// Update db for attempt and intent status.
db.update_payment_intent(
payment_data.payment_intent.clone(),
storage::PaymentIntentUpdate::RejectUpdate {
status: common_enums::IntentStatus::Failed,
merchant_decision: Some(MerchantDecision::Rejected.to_string()),
updated_by: platform
.get_processor()
.get_account()
.storage_scheme
.to_string(),
},
platform.get_processor().get_key_store(),
platform.get_processor().get_account().storage_scheme,
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)
.attach_printable(
"Failed to update status in Payment Intent to failed due to it being blocklisted",
)?;
// If payment is blocked not showing connector details
let attempt_update = storage::PaymentAttemptUpdate::BlocklistUpdate {
status: common_enums::AttemptStatus::Failure,
error_code: Some(Some("HE-03".to_string())),
error_message: Some(Some("This payment method is blocked".to_string())),
updated_by: platform
.get_processor()
.get_account()
.storage_scheme
.to_string(),
};
db.update_payment_attempt_with_attempt_id(
payment_data.payment_attempt.clone(),
attempt_update,
platform.get_processor().get_account().storage_scheme,
platform.get_processor().get_key_store(),
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)
.attach_printable(
"Failed to update status in Payment Attempt to failed, due to it being blocklisted",
)?;
Err(errors::ApiErrorResponse::PaymentBlockedError {
code: 200,
message: "This payment method is blocked".to_string(),
status: "Failed".to_string(),
reason: "Blocked".to_string(),
}
.into())
} else {
payment_data.payment_attempt.fingerprint_id = generate_payment_fingerprint(
state,
payment_data.payment_attempt.merchant_id.clone(),
payment_data.payment_method_data.clone(),
)
.await?;
Ok(false)
}
}
pub async fn generate_payment_fingerprint(
state: &SessionState,
merchant_id: common_utils::id_type::MerchantId,
payment_method_data: Option<domain::PaymentMethodData>,
) -> CustomResult<Option<String>, errors::ApiErrorResponse> {
let merchant_fingerprint_secret = get_merchant_fingerprint_secret(state, &merchant_id).await?;
Ok(
if let Some(domain::PaymentMethodData::Card(card)) = payment_method_data.as_ref() {
generate_fingerprint(
state,
StrongSecret::new(card.card_number.get_card_no()),
StrongSecret::new(merchant_fingerprint_secret),
)
.await
.attach_printable("error in pm fingerprint creation")
.map_or_else(
|error| {
logger::error!(?error);
None
},
Some,
)
.map(|payload| payload.fingerprint_id)
} else {
logger::error!("failed to retrieve card fingerprint");
None
},
)
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/blocklist/transformers.rs | crates/router/src/core/blocklist/transformers.rs | use api_models::blocklist;
use error_stack::ResultExt;
use masking::StrongSecret;
use router_env::{instrument, tracing};
use crate::{
core::{
errors::{self, CustomResult},
payment_methods::transformers as payment_methods,
},
routes,
types::{storage, transformers::ForeignFrom},
};
const LOCKER_FINGERPRINT_PATH: &str = "/cards/fingerprint";
impl ForeignFrom<storage::Blocklist> for blocklist::AddToBlocklistResponse {
fn foreign_from(from: storage::Blocklist) -> Self {
Self {
fingerprint_id: from.fingerprint_id,
data_kind: from.data_kind,
created_at: from.created_at,
}
}
}
#[instrument(skip_all)]
pub async fn generate_fingerprint(
state: &routes::SessionState,
card_number: StrongSecret<String>,
hash_key: StrongSecret<String>,
) -> CustomResult<blocklist::GenerateFingerprintResponsePayload, errors::VaultError> {
let payload = blocklist::GenerateFingerprintRequest {
data: card_number,
key: hash_key,
};
let generate_fingerprint_resp = call_to_vault_for_fingerprint(state, &payload).await?;
Ok(generate_fingerprint_resp)
}
#[instrument(skip_all)]
async fn call_to_vault_for_fingerprint(
state: &routes::SessionState,
payload: &blocklist::GenerateFingerprintRequest,
) -> CustomResult<blocklist::GenerateFingerprintResponsePayload, errors::VaultError> {
let locker = &state.conf.locker;
let jwekey = state.conf.jwekey.get_inner();
let generate_fingerprint_response: blocklist::GenerateFingerprintResponsePayload =
payment_methods::call_vault_api(
state,
jwekey,
locker,
payload,
LOCKER_FINGERPRINT_PATH,
state.tenant.tenant_id.clone(),
state.request_id.clone(),
)
.await
.change_context(errors::VaultError::GenerateFingerprintFailed)?;
Ok(generate_fingerprint_response)
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/unified_connector_service/transformers.rs | crates/router/src/core/unified_connector_service/transformers.rs | use std::{collections::HashMap, str::FromStr};
use api_models::payments::{
AmountInfo, ApplePayAddressParameters, ApplePayPaymentRequest, ApplePaySessionResponse,
ApplepaySessionTokenResponse, GooglePaySessionResponse, GpayAllowedMethodsParameters,
GpayAllowedPaymentMethods, GpayBillingAddressFormat, GpayBillingAddressParameters,
GpayMerchantInfo, GpaySessionTokenResponse, GpayShippingAddressParameters, GpayTokenParameters,
GpayTokenizationSpecification, GpayTransactionInfo, NextActionCall, PaypalFlow,
PaypalSessionTokenResponse, PaypalTransactionInfo, SdkNextAction, SecretInfoToInitiateSdk,
SessionToken, ThirdPartySdkSessionResponse,
};
use common_enums::{AttemptStatus, AuthenticationType, RefundStatus};
use common_utils::{
ext_traits::Encode,
request::Method,
types::{self, AmountConvertor, MinorUnit, StringMajorUnitForConnector},
};
use diesel_models::enums as storage_enums;
use error_stack::{report, ResultExt};
use external_services::grpc_client::unified_connector_service::UnifiedConnectorServiceError;
use hyperswitch_domain_models::{
mandates::MandateData,
router_data::{AccessToken, ErrorResponse, RouterData},
router_flow_types::{
payments::{Authorize, Capture, PSync, SetupMandate},
refunds::{Execute, RSync},
unified_authentication_service as uas_flows, ExternalVaultProxy, Session,
},
router_request_types::{
self, AuthenticationData, ExternalVaultProxyPaymentsData, PaymentsAuthorizeData,
PaymentsCancelData, PaymentsCaptureData, PaymentsSessionData, PaymentsSyncData,
RefundsData, SetupMandateRequestData, SyncRequestType,
},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
};
pub use hyperswitch_interfaces::{
helpers::ForeignTryFrom,
unified_connector_service::{
transformers::convert_connector_service_status_code, WebhookTransformData,
WebhookTransformationStatus,
},
};
use masking::{ExposeInterface, PeekInterface, Secret};
use router_env::tracing;
use time::{Duration, OffsetDateTime};
use unified_connector_service_cards::CardNumber;
use unified_connector_service_client::payments::{
self as payments_grpc, session_token, ConnectorState, Identifier,
PaymentServiceTransformRequest, PaymentServiceTransformResponse,
};
use unified_connector_service_masking::ExposeInterface as UcsMaskingExposeInterface;
use crate::{
core::{errors, mandate::MandateBehaviour, unified_connector_service},
types::{
api,
transformers::{self, ForeignFrom},
},
};
const UPI_WAIT_SCREEN_DISPLAY_DURATION_MINUTES: i64 = 5;
const UPI_POLL_DELAY_IN_SECS: u16 = 5;
const UPI_POLL_FREQUENCY: u16 = 60;
pub fn build_upi_wait_screen_data(
) -> Result<serde_json::Value, error_stack::Report<UnifiedConnectorServiceError>> {
let current_time = OffsetDateTime::now_utc().unix_timestamp_nanos();
let wait_screen_data = api_models::payments::WaitScreenInstructions {
display_from_timestamp: current_time,
display_to_timestamp: Some(
current_time
+ Duration::minutes(UPI_WAIT_SCREEN_DISPLAY_DURATION_MINUTES).whole_nanoseconds(),
),
poll_config: Some(api_models::payments::PollConfig {
delay_in_secs: UPI_POLL_DELAY_IN_SECS,
frequency: UPI_POLL_FREQUENCY,
}),
};
serde_json::to_value(wait_screen_data)
.change_context(UnifiedConnectorServiceError::ParsingFailed)
.attach_printable("Failed to serialize WaitScreenInstructions to JSON value")
}
/// Utility function to convert serde_json::Value map to HashMap<String, String>
/// Propagates serialization errors instead of using defaults
fn convert_value_map_to_hashmap(
value: &serde_json::Value,
) -> Result<HashMap<String, String>, error_stack::Report<UnifiedConnectorServiceError>> {
match value.as_object() {
Some(map) => map
.iter()
.map(|(k, v)| {
let string_value = v
.as_str()
.map(|s| s.to_string())
.or_else(|| {
serde_json::to_string(v)
.ok()
})
.ok_or_else(|| {
error_stack::Report::new(
UnifiedConnectorServiceError::RequestEncodingFailedWithReason(format!(
"Failed to serialize metadata value for key: {}",
k
))
)
})?;
Ok::<_, error_stack::Report<UnifiedConnectorServiceError>>((k.clone(), string_value))
})
.collect::<Result<HashMap<String, String>, error_stack::Report<UnifiedConnectorServiceError>>>(),
None => Ok(HashMap::new()),
}
}
impl ForeignFrom<&payments_grpc::AccessToken> for AccessToken {
fn foreign_from(grpc_token: &payments_grpc::AccessToken) -> Self {
Self {
token: Secret::new(grpc_token.token.clone()),
expires: grpc_token.expires_in_seconds.unwrap_or_default(),
}
}
}
impl ForeignFrom<&AccessToken> for ConnectorState {
fn foreign_from(access_token: &AccessToken) -> Self {
Self {
access_token: Some(payments_grpc::AccessToken {
token: access_token.token.peek().to_string(),
expires_in_seconds: Some(access_token.expires),
token_type: None,
}),
connector_customer_id: None,
}
}
}
impl
transformers::ForeignTryFrom<
&RouterData<
api::PaymentMethodToken,
router_request_types::PaymentMethodTokenizationData,
PaymentsResponseData,
>,
> for payments_grpc::PaymentServiceCreatePaymentMethodTokenRequest
{
type Error = error_stack::Report<UnifiedConnectorServiceError>;
fn foreign_try_from(
router_data: &RouterData<
api::PaymentMethodToken,
router_request_types::PaymentMethodTokenizationData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
let connector_ref_id = Identifier {
id_type: Some(payments_grpc::identifier::IdType::Id(
router_data.connector_request_reference_id.clone(),
)),
};
let merchant_account_metadata = router_data
.connector_meta_data
.as_ref()
.map(|secret| convert_value_map_to_hashmap(secret.peek()))
.transpose()?
.unwrap_or_default();
let currency = payments_grpc::Currency::foreign_try_from(router_data.request.currency)?;
let payment_method = router_data
.request
.payment_method_type
.map(|payment_method_type| {
unified_connector_service::build_unified_connector_service_payment_method(
router_data.request.payment_method_data.clone(),
Some(payment_method_type),
)
})
.transpose()?;
// TODO: Fix the type of address field in UCS request and pass address
// let address = payments_grpc::PaymentAddress::foreign_try_from(router_data.address.clone())?;
let amount = router_data.request.amount.ok_or(report!(
UnifiedConnectorServiceError::MissingRequiredField {
field_name: "amount"
}
))?;
Ok(Self {
request_ref_id: Some(connector_ref_id),
merchant_account_metadata,
amount,
currency: currency.into(),
minor_amount: amount,
payment_method,
customer_name: None,
email: None,
customer_id: None,
address: None,
metadata: HashMap::new(),
connector_metadata: HashMap::new(),
return_url: router_data.request.router_return_url.clone(),
})
}
}
impl
transformers::ForeignTryFrom<(
&RouterData<Authorize, PaymentsAuthorizeData, PaymentsResponseData>,
common_enums::CallConnectorAction,
)> for payments_grpc::PaymentServiceAuthorizeOnlyRequest
{
type Error = error_stack::Report<UnifiedConnectorServiceError>;
fn foreign_try_from(
(router_data, _call_connector_action): (
&RouterData<Authorize, PaymentsAuthorizeData, PaymentsResponseData>,
common_enums::CallConnectorAction,
),
) -> Result<Self, Self::Error> {
let currency = payments_grpc::Currency::foreign_try_from(router_data.request.currency)?;
let payment_method = Some(
unified_connector_service::build_unified_connector_service_payment_method(
router_data.request.payment_method_data.clone(),
router_data.request.payment_method_type,
)?,
);
let address = payments_grpc::PaymentAddress::foreign_try_from(router_data.address.clone())?;
let auth_type = payments_grpc::AuthenticationType::foreign_try_from(router_data.auth_type)?;
let browser_info = router_data
.request
.browser_info
.clone()
.map(payments_grpc::BrowserInformation::foreign_try_from)
.transpose()?;
let capture_method = router_data
.request
.capture_method
.map(payments_grpc::CaptureMethod::foreign_try_from)
.transpose()?;
let authentication_data = router_data
.request
.authentication_data
.clone()
.map(payments_grpc::AuthenticationData::foreign_try_from)
.transpose()?;
let merchant_account_metadata = router_data
.connector_meta_data
.as_ref()
.map(|secret| convert_value_map_to_hashmap(secret.peek()))
.transpose()?
.unwrap_or_default();
let metadata = router_data
.request
.metadata
.as_ref()
.map(convert_value_map_to_hashmap)
.transpose()?
.unwrap_or_default();
let setup_future_usage = router_data
.request
.setup_future_usage
.map(payments_grpc::FutureUsage::foreign_try_from)
.transpose()?;
let customer_acceptance = router_data
.request
.customer_acceptance
.clone()
.map(payments_grpc::CustomerAcceptance::foreign_try_from)
.transpose()?;
let state = router_data
.access_token
.as_ref()
.map(ConnectorState::foreign_from);
Ok(Self {
connector_order_reference_id: router_data.request.order_id.clone(),
amount: router_data.request.amount,
currency: currency.into(),
payment_method,
return_url: router_data.request.router_return_url.clone(),
address: Some(address),
auth_type: auth_type.into(),
enrolled_for_3ds: Some(router_data.request.enrolled_for_3ds),
request_incremental_authorization: Some(
router_data.request.request_incremental_authorization,
),
minor_amount: router_data.request.amount,
email: router_data
.request
.email
.clone()
.map(|e| e.expose().expose().into()),
browser_info,
session_token: router_data.session_token.clone(),
order_tax_amount: router_data
.request
.order_tax_amount
.map(|order_tax_amount| order_tax_amount.get_amount_as_i64()),
customer_name: router_data
.request
.customer_name
.clone()
.map(|customer_name| customer_name.peek().to_owned()),
capture_method: capture_method.map(|capture_method| capture_method.into()),
webhook_url: router_data.request.webhook_url.clone(),
complete_authorize_url: router_data.request.complete_authorize_url.clone(),
setup_future_usage: setup_future_usage.map(|s| s.into()),
off_session: router_data.request.off_session,
customer_acceptance,
order_category: router_data.request.order_category.clone(),
payment_experience: None,
authentication_data,
request_extended_authorization: router_data
.request
.request_extended_authorization
.map(|request_extended_authorization| request_extended_authorization.is_true()),
merchant_order_reference_id: router_data.request.merchant_order_reference_id.clone(),
shipping_cost: router_data
.request
.shipping_cost
.map(|shipping_cost| shipping_cost.get_amount_as_i64()),
request_ref_id: Some(Identifier {
id_type: Some(payments_grpc::identifier::IdType::Id(
router_data.connector_request_reference_id.clone(),
)),
}),
customer_id: router_data
.request
.customer_id
.as_ref()
.map(|id| id.get_string_repr().to_string()),
metadata,
test_mode: router_data.test_mode,
connector_customer_id: router_data.connector_customer.clone(),
state,
payment_method_token: router_data
.payment_method_token
.as_ref()
.and_then(|pmt| pmt.get_payment_method_token())
.map(ExposeInterface::expose),
merchant_account_metadata,
description: router_data.description.clone(),
setup_mandate_details: router_data
.request
.setup_mandate_details
.as_ref()
.map(payments_grpc::SetupMandateDetails::foreign_try_from)
.transpose()?,
statement_descriptor_name: router_data
.request
.billing_descriptor
.as_ref()
.and_then(|descriptor| descriptor.statement_descriptor.clone()),
statement_descriptor_suffix: router_data
.request
.billing_descriptor
.as_ref()
.and_then(|descriptor| descriptor.statement_descriptor_suffix.clone()),
order_details: vec![],
enable_partial_authorization: router_data
.request
.enable_partial_authorization
.map(|e| e.is_true()),
billing_descriptor: router_data
.request
.billing_descriptor
.as_ref()
.map(payments_grpc::BillingDescriptor::foreign_from),
payment_channel: router_data
.request
.payment_channel
.as_ref()
.map(payments_grpc::PaymentChannel::foreign_try_from)
.transpose()?
.map(|payment_channel| payment_channel.into()),
connector_metadata: HashMap::new(),
})
}
}
impl
transformers::ForeignTryFrom<(
&RouterData<
api::CompleteAuthorize,
router_request_types::CompleteAuthorizeData,
PaymentsResponseData,
>,
common_enums::CallConnectorAction,
)> for payments_grpc::PaymentServiceAuthorizeOnlyRequest
{
type Error = error_stack::Report<UnifiedConnectorServiceError>;
fn foreign_try_from(
(router_data, _call_connector_action): (
&RouterData<
api::CompleteAuthorize,
router_request_types::CompleteAuthorizeData,
PaymentsResponseData,
>,
common_enums::CallConnectorAction,
),
) -> Result<Self, Self::Error> {
let currency = payments_grpc::Currency::foreign_try_from(router_data.request.currency)?;
let payment_method = router_data
.request
.payment_method_data
.clone()
.map(|payment_method_data| {
unified_connector_service::build_unified_connector_service_payment_method(
payment_method_data,
router_data.request.payment_method_type,
)
})
.transpose()?;
let address = payments_grpc::PaymentAddress::foreign_try_from(router_data.address.clone())?;
let auth_type = payments_grpc::AuthenticationType::foreign_try_from(router_data.auth_type)?;
let browser_info = router_data
.request
.browser_info
.clone()
.map(payments_grpc::BrowserInformation::foreign_try_from)
.transpose()?;
let capture_method = router_data
.request
.capture_method
.map(payments_grpc::CaptureMethod::foreign_try_from)
.transpose()?;
let authentication_data = router_data
.request
.authentication_data
.clone()
.map(payments_grpc::AuthenticationData::foreign_try_from)
.transpose()?;
let merchant_account_metadata = router_data
.connector_meta_data
.as_ref()
.map(|secret| convert_value_map_to_hashmap(secret.peek()))
.transpose()?
.unwrap_or_default();
let metadata = router_data
.request
.metadata
.as_ref()
.and_then(|val| val.as_object())
.map(|map| {
map.iter()
.filter_map(|(k, v)| v.as_str().map(|s| (k.clone(), s.to_string())))
.collect::<HashMap<String, String>>()
})
.unwrap_or_default();
let setup_future_usage = router_data
.request
.setup_future_usage
.map(payments_grpc::FutureUsage::foreign_try_from)
.transpose()?;
let customer_acceptance = router_data
.request
.customer_acceptance
.clone()
.map(payments_grpc::CustomerAcceptance::foreign_try_from)
.transpose()?;
let state = router_data
.access_token
.as_ref()
.map(ConnectorState::foreign_from);
Ok(Self {
connector_order_reference_id: None,
amount: router_data.request.amount,
currency: currency.into(),
payment_method,
return_url: router_data.request.router_return_url.clone(),
address: Some(address),
auth_type: auth_type.into(),
enrolled_for_3ds: Some(true),
request_incremental_authorization: Some(
router_data.request.request_incremental_authorization,
),
minor_amount: router_data.request.amount,
email: router_data
.request
.email
.clone()
.map(|e| e.expose().expose().into()),
browser_info,
session_token: router_data.session_token.clone(),
order_tax_amount: None,
customer_name: None,
capture_method: capture_method.map(|capture_method| capture_method.into()),
webhook_url: None,
complete_authorize_url: router_data.request.complete_authorize_url.clone(),
setup_future_usage: setup_future_usage.map(|s| s.into()),
off_session: router_data.request.off_session,
customer_acceptance,
order_category: None,
payment_experience: None,
authentication_data,
request_extended_authorization: None,
merchant_order_reference_id: None,
shipping_cost: None,
request_ref_id: Some(Identifier {
id_type: Some(payments_grpc::identifier::IdType::Id(
router_data.connector_request_reference_id.clone(),
)),
}),
customer_id: None,
metadata,
test_mode: router_data.test_mode,
connector_customer_id: router_data.connector_customer.clone(),
state,
payment_method_token: router_data
.payment_method_token
.as_ref()
.and_then(|pmt| pmt.get_payment_method_token())
.map(ExposeInterface::expose),
merchant_account_metadata,
description: router_data.description.clone(),
setup_mandate_details: router_data
.request
.setup_mandate_details
.as_ref()
.map(payments_grpc::SetupMandateDetails::foreign_try_from)
.transpose()?,
statement_descriptor_name: None,
statement_descriptor_suffix: None,
order_details: vec![],
connector_metadata: HashMap::new(),
enable_partial_authorization: None,
payment_channel: None,
billing_descriptor: None,
})
}
}
impl
transformers::ForeignTryFrom<
&RouterData<
api::CreateOrder,
router_request_types::CreateOrderRequestData,
PaymentsResponseData,
>,
> for payments_grpc::PaymentServiceCreateOrderRequest
{
type Error = error_stack::Report<UnifiedConnectorServiceError>;
fn foreign_try_from(
router_data: &RouterData<
api::CreateOrder,
router_request_types::CreateOrderRequestData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
let currency = payments_grpc::Currency::foreign_try_from(router_data.request.currency)?;
// Populate state with access token if available (same pattern as Authorize flow)
let state = router_data
.access_token
.as_ref()
.map(ConnectorState::foreign_from);
Ok(Self {
request_ref_id: Some(Identifier {
id_type: Some(payments_grpc::identifier::IdType::Id(
router_data.connector_request_reference_id.clone(),
)),
}),
amount: router_data.request.minor_amount.get_amount_as_i64(),
currency: currency.into(),
metadata: HashMap::new(),
webhook_url: None,
connector_metadata: HashMap::new(),
merchant_account_metadata: HashMap::new(),
state,
})
}
}
impl
transformers::ForeignTryFrom<(
&RouterData<
hyperswitch_domain_models::router_flow_types::payments::CreateConnectorCustomer,
router_request_types::ConnectorCustomerData,
PaymentsResponseData,
>,
common_enums::CallConnectorAction,
)> for payments_grpc::PaymentServiceCreateConnectorCustomerRequest
{
type Error = error_stack::Report<UnifiedConnectorServiceError>;
fn foreign_try_from(
(router_data, _call_connector_action): (
&RouterData<
hyperswitch_domain_models::router_flow_types::payments::CreateConnectorCustomer,
router_request_types::ConnectorCustomerData,
PaymentsResponseData,
>,
common_enums::CallConnectorAction,
),
) -> Result<Self, Self::Error> {
let request_ref_id = router_data.connector_request_reference_id.clone();
let address = payments_grpc::PaymentAddress::foreign_try_from(router_data.address.clone())?;
Ok(Self {
request_ref_id: Some(Identifier {
id_type: Some(payments_grpc::identifier::IdType::Id(request_ref_id)),
}),
merchant_account_metadata: HashMap::new(),
customer_name: router_data
.request
.name
.clone()
.map(ExposeInterface::expose),
email: router_data
.request
.email
.clone()
.map(|e| e.expose().expose().into()),
customer_id: router_data
.customer_id
.clone()
.map(|id| id.get_string_repr().to_string()),
phone_number: router_data
.request
.phone
.as_ref()
.map(|phone| phone.peek().to_string()),
address: Some(address),
metadata: HashMap::new(),
connector_metadata: HashMap::new(),
})
}
}
impl
transformers::ForeignTryFrom<(
&RouterData<PSync, PaymentsSyncData, PaymentsResponseData>,
common_enums::CallConnectorAction,
)> for payments_grpc::PaymentServiceGetRequest
{
type Error = error_stack::Report<UnifiedConnectorServiceError>;
fn foreign_try_from(
(router_data, call_connector_action): (
&RouterData<PSync, PaymentsSyncData, PaymentsResponseData>,
common_enums::CallConnectorAction,
),
) -> Result<Self, Self::Error> {
let connector_transaction_id = router_data
.request
.connector_transaction_id
.get_connector_transaction_id()
.map(|id| Identifier {
id_type: Some(payments_grpc::identifier::IdType::Id(id)),
})
.map_err(|e| {
tracing::debug!(
transaction_id_error=?e,
"Failed to extract connector transaction ID for UCS payment sync request"
);
e
})
.ok();
let connector_order_reference_id = router_data.request.connector_reference_id.clone();
let request_ref_id = Some(Identifier {
id_type: Some(payments_grpc::identifier::IdType::Id(
router_data.connector_request_reference_id.clone(),
)),
});
let currency = payments_grpc::Currency::foreign_try_from(router_data.request.currency)?;
let handle_response = match call_connector_action {
common_enums::CallConnectorAction::UCSHandleResponse(res) => Some(res),
common_enums::CallConnectorAction::Trigger => None,
common_enums::CallConnectorAction::HandleResponse(_)
| common_enums::CallConnectorAction::UCSConsumeResponse(_)
| common_enums::CallConnectorAction::Avoid
| common_enums::CallConnectorAction::StatusUpdate { .. } => Err(
UnifiedConnectorServiceError::RequestEncodingFailedWithReason(
"Invalid CallConnectorAction for payment sync call via UCS Gateway system"
.to_string(),
),
)?,
};
let capture_method = router_data
.request
.capture_method
.map(payments_grpc::CaptureMethod::foreign_try_from)
.transpose()?;
let state = router_data
.access_token
.as_ref()
.map(ConnectorState::foreign_from);
let setup_future_usage = router_data
.request
.setup_future_usage
.map(payments_grpc::FutureUsage::foreign_try_from)
.transpose()?;
Ok(Self {
transaction_id: connector_transaction_id,
encoded_data: router_data.request.encoded_data.clone(),
request_ref_id,
capture_method: capture_method.map(|capture_method| capture_method.into()),
handle_response,
setup_future_usage: setup_future_usage.map(|s| s.into()),
connector_order_reference_id,
amount: router_data.request.amount.get_amount_as_i64(),
currency: currency.into(),
state,
connector_metadata: router_data
.request
.connector_meta
.as_ref()
.map(serde_json::to_string)
.transpose()
.change_context(UnifiedConnectorServiceError::RequestEncodingFailed)?
.map(|s| s.into()),
sync_type: Some(
payments_grpc::SyncRequestType::foreign_from(&router_data.request.sync_type).into(),
),
merchant_account_metadata: HashMap::new(),
metadata: HashMap::new(),
})
}
}
impl
transformers::ForeignTryFrom<
&RouterData<
api::AuthorizeSessionToken,
router_request_types::AuthorizeSessionTokenData,
PaymentsResponseData,
>,
> for payments_grpc::PaymentServiceCreateSessionTokenRequest
{
type Error = error_stack::Report<UnifiedConnectorServiceError>;
fn foreign_try_from(
router_data: &RouterData<
api::AuthorizeSessionToken,
router_request_types::AuthorizeSessionTokenData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
let currency = payments_grpc::Currency::foreign_try_from(router_data.request.currency)?;
Ok(Self {
request_ref_id: Some(Identifier {
id_type: Some(payments_grpc::identifier::IdType::Id(
router_data.connector_request_reference_id.clone(),
)),
}),
amount: router_data
.request
.amount
.ok_or(report!(UnifiedConnectorServiceError::RequestEncodingFailed))?,
currency: currency.into(),
minor_amount: router_data
.request
.amount
.ok_or(report!(UnifiedConnectorServiceError::RequestEncodingFailed))?,
metadata: HashMap::new(),
state: None,
browser_info: None,
connector_metadata: HashMap::new(),
merchant_account_metadata: HashMap::new(),
})
}
}
impl
transformers::ForeignTryFrom<
&RouterData<
uas_flows::Authenticate,
router_request_types::PaymentsAuthenticateData,
PaymentsResponseData,
>,
> for payments_grpc::PaymentServiceAuthenticateRequest
{
type Error = error_stack::Report<UnifiedConnectorServiceError>;
fn foreign_try_from(
router_data: &RouterData<
uas_flows::Authenticate,
router_request_types::PaymentsAuthenticateData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
let currency = payments_grpc::Currency::foreign_try_from(
router_data.request.currency.unwrap_or_default(),
)?;
let payment_method = router_data
.request
.payment_method_data
.clone()
.map(|payment_method_data| {
unified_connector_service::build_unified_connector_service_payment_method(
payment_method_data,
router_data.request.payment_method_type,
)
})
.transpose()?;
let address = payments_grpc::PaymentAddress::foreign_try_from(router_data.address.clone())?;
let merchant_account_metadata = router_data
.connector_meta_data
.as_ref()
.map(|val| convert_value_map_to_hashmap(val.peek()))
.transpose()?
.unwrap_or_default();
Ok(Self {
request_ref_id: Some(Identifier {
id_type: Some(payments_grpc::identifier::IdType::Id(
router_data.connector_request_reference_id.clone(),
)),
}),
amount: router_data.request.amount.unwrap_or(0),
currency: currency.into(),
minor_amount: router_data
.request
.minor_amount
.map(|amount| amount.get_amount_as_i64())
.unwrap_or(0),
payment_method,
email: router_data
.request
.email
.clone()
.map(|e| e.expose().expose().into()),
customer_name: None,
address: Some(address),
authentication_data: None,
metadata: HashMap::new(),
return_url: None,
continue_redirection_url: router_data.request.complete_authorize_url.clone(),
state: None,
redirection_response: router_data
.request
.redirect_response
.clone()
.map(|redirection_response| {
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | true |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/payouts/access_token.rs | crates/router/src/core/payouts/access_token.rs | use common_utils::ext_traits::AsyncExt;
use error_stack::ResultExt;
use hyperswitch_interfaces::api::{ConnectorAccessTokenSuffix, ConnectorCommon};
use crate::{
consts,
core::{
errors::{self, RouterResult},
payments,
},
routes::{metrics, SessionState},
services,
types::{self, api as api_types, domain, storage::enums},
};
/// After we get the access token, check if there was an error and if the flow should proceed further
/// Everything is well, continue with the flow
/// There was an error, cannot proceed further
#[cfg(feature = "payouts")]
pub async fn create_access_token<F: Clone + 'static>(
state: &SessionState,
connector_data: &api_types::ConnectorData,
platform: &domain::Platform,
router_data: &mut types::PayoutsRouterData<F>,
payout_type: Option<enums::PayoutType>,
) -> RouterResult<()> {
let connector_access_token =
add_access_token_for_payout(state, connector_data, platform, router_data, payout_type)
.await?;
if connector_access_token.connector_supports_access_token {
match connector_access_token.access_token_result {
Ok(access_token) => {
router_data.access_token = access_token;
}
Err(connector_error) => {
router_data.response = Err(connector_error);
}
}
}
Ok(())
}
#[cfg(feature = "payouts")]
pub async fn add_access_token_for_payout<F: Clone + 'static>(
state: &SessionState,
connector: &api_types::ConnectorData,
platform: &domain::Platform,
router_data: &types::PayoutsRouterData<F>,
payout_type: Option<enums::PayoutType>,
) -> RouterResult<types::AddAccessTokenResult> {
if connector
.connector_name
.supports_access_token_for_payout(payout_type)
{
let store = &*state.store;
let key = connector
.connector
.get_access_token_key(router_data, connector.connector.id().to_string())
.change_context(errors::ApiErrorResponse::InternalServerError)?;
let old_access_token = store
.get_access_token(key.clone())
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("DB error when accessing the access token")?;
let res = match old_access_token {
Some(access_token) => Ok(Some(access_token)),
None => {
let cloned_router_data = router_data.clone();
let refresh_token_request_data = types::AccessTokenRequestData::try_from(
router_data.connector_auth_type.clone(),
)
.attach_printable(
"Could not create access token request, invalid connector account credentials",
)?;
let refresh_token_response_data: Result<types::AccessToken, types::ErrorResponse> =
Err(types::ErrorResponse::default());
let refresh_token_router_data = payments::helpers::router_data_type_conversion::<
_,
api_types::AccessTokenAuth,
_,
_,
_,
_,
>(
cloned_router_data,
refresh_token_request_data,
refresh_token_response_data,
);
refresh_connector_auth(state, connector, platform, &refresh_token_router_data)
.await?
.async_map(|access_token| async {
//Store the access token in db
let store = &*state.store;
// This error should not be propagated, we don't want payments to fail once we have
// the access token, the next request will create new access token
let _ = store
.set_access_token(key, access_token.clone())
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("DB error when setting the access token");
Some(access_token)
})
.await
}
};
Ok(types::AddAccessTokenResult {
access_token_result: res,
connector_supports_access_token: true,
})
} else {
Ok(types::AddAccessTokenResult {
access_token_result: Err(types::ErrorResponse::default()),
connector_supports_access_token: false,
})
}
}
#[cfg(feature = "payouts")]
pub async fn refresh_connector_auth(
state: &SessionState,
connector: &api_types::ConnectorData,
_platform: &domain::Platform,
router_data: &types::RouterData<
api_types::AccessTokenAuth,
types::AccessTokenRequestData,
types::AccessToken,
>,
) -> RouterResult<Result<types::AccessToken, types::ErrorResponse>> {
let connector_integration: services::BoxedAccessTokenConnectorIntegrationInterface<
api_types::AccessTokenAuth,
types::AccessTokenRequestData,
types::AccessToken,
> = connector.connector.get_connector_integration();
let access_token_router_data_result = services::execute_connector_processing_step(
state,
connector_integration,
router_data,
payments::CallConnectorAction::Trigger,
None,
None,
)
.await;
let access_token_router_data = match access_token_router_data_result {
Ok(router_data) => Ok(router_data.response),
Err(connector_error) => {
// If we receive a timeout error from the connector, then
// the error has to be handled gracefully by updating the payment status to failed.
// further payment flow will not be continued
if connector_error.current_context().is_connector_timeout() {
let error_response = types::ErrorResponse {
code: consts::REQUEST_TIMEOUT_ERROR_CODE.to_string(),
message: consts::REQUEST_TIMEOUT_ERROR_MESSAGE.to_string(),
reason: Some(consts::REQUEST_TIMEOUT_ERROR_MESSAGE.to_string()),
status_code: 504,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
};
Ok(Err(error_response))
} else {
Err(connector_error
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Could not refresh access token"))
}
}
}?;
metrics::ACCESS_TOKEN_CREATION.add(
1,
router_env::metric_attributes!(("connector", connector.connector_name.to_string())),
);
Ok(access_token_router_data)
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/payouts/helpers.rs | crates/router/src/core/payouts/helpers.rs | use ::payment_methods::controller::PaymentMethodsController;
use api_models::{enums, payment_methods::Card, payouts};
use common_utils::{
crypto::Encryptable,
encryption::Encryption,
errors::CustomResult,
ext_traits::{AsyncExt, StringExt, ValueExt},
fp_utils, id_type, payout_method_utils as payout_additional, pii, type_name,
types::{
keymanager::{Identifier, KeyManagerState},
MinorUnit, UnifiedCode, UnifiedMessage,
},
};
#[cfg(feature = "v1")]
use common_utils::{generate_customer_id_of_default_length, types::keymanager::ToEncryptable};
use error_stack::{report, ResultExt};
use hyperswitch_domain_models::type_encryption::{crypto_operation, CryptoOperation};
use masking::{ExposeInterface, PeekInterface, Secret, SwitchStrategy};
use router_env::logger;
use super::PayoutData;
#[cfg(feature = "payouts")]
use crate::core::payments::route_connector_v1_for_payouts;
use crate::{
consts,
core::{
errors::{self, RouterResult, StorageErrorExt},
payment_methods::{
cards,
transformers::{DataDuplicationCheck, StoreCardReq, StoreGenericReq, StoreLockerReq},
vault,
},
payments::{helpers as payment_helpers, routing, CustomerDetails},
routing::TransactionData,
utils as core_utils,
},
db::StorageInterface,
routes::{metrics, SessionState},
services,
types::{
self as router_types,
api::{self, enums as api_enums},
domain::{self, types::AsyncLift},
storage,
transformers::ForeignFrom,
},
utils::{self, OptionExt},
};
#[allow(clippy::too_many_arguments)]
pub async fn make_payout_method_data(
state: &SessionState,
payout_method_data: Option<&api::PayoutMethodData>,
payout_token: Option<&str>,
customer_id: &id_type::CustomerId,
merchant_id: &id_type::MerchantId,
payout_type: Option<api_enums::PayoutType>,
merchant_key_store: &domain::MerchantKeyStore,
payout_data: Option<&mut PayoutData>,
storage_scheme: storage::enums::MerchantStorageScheme,
) -> RouterResult<Option<api::PayoutMethodData>> {
let db = &*state.store;
let hyperswitch_token = if let Some(payout_token) = payout_token {
if payout_token.starts_with("temporary_token_") {
Some(payout_token.to_string())
} else {
let certain_payout_type = payout_type.get_required_value("payout_type")?.to_owned();
let key = format!(
"pm_token_{}_{}_hyperswitch",
payout_token,
api_enums::PaymentMethod::foreign_from(certain_payout_type)
);
let redis_conn = state
.store
.get_redis_conn()
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed to get redis connection")?;
let hyperswitch_token = redis_conn
.get_key::<Option<String>>(&key.into())
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed to fetch the token from redis")?
.ok_or(error_stack::Report::new(
errors::ApiErrorResponse::UnprocessableEntity {
message: "Token is invalid or expired".to_owned(),
},
))?;
let payment_token_data = hyperswitch_token
.clone()
.parse_struct("PaymentTokenData")
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("failed to deserialize hyperswitch token data")?;
let payment_token = match payment_token_data {
storage::PaymentTokenData::PermanentCard(storage::CardTokenData {
locker_id,
token,
..
}) => locker_id.or(Some(token)),
storage::PaymentTokenData::TemporaryGeneric(storage::GenericTokenData {
token,
}) => Some(token),
_ => None,
};
payment_token.or(Some(payout_token.to_string()))
}
} else {
None
};
match (
payout_method_data.to_owned(),
hyperswitch_token,
payout_data,
) {
// Get operation
(None, Some(payout_token), _) => {
if payout_token.starts_with("temporary_token_")
|| payout_type == Some(api_enums::PayoutType::Bank)
{
let (pm, supplementary_data) = vault::Vault::get_payout_method_data_from_temporary_locker(
state,
&payout_token,
merchant_key_store,
)
.await
.attach_printable(
"Payout method for given token not found or there was a problem fetching it",
)?;
utils::when(
supplementary_data
.customer_id
.ne(&Some(customer_id.to_owned())),
|| {
Err(errors::ApiErrorResponse::PreconditionFailed { message: "customer associated with payout method and customer passed in payout are not same".into() })
},
)?;
Ok(pm)
} else {
let resp = cards::get_card_from_locker(
state,
customer_id,
merchant_id,
payout_token.as_ref(),
)
.await
.attach_printable("Payout method [card] could not be fetched from HS locker")?
.get_card();
Ok(Some({
api::PayoutMethodData::Card(api::CardPayout {
card_number: resp.card_number,
expiry_month: resp.card_exp_month,
expiry_year: resp.card_exp_year,
card_holder_name: resp.name_on_card,
card_network: None,
})
}))
}
}
// Create / Update operation
(Some(payout_method), payout_token, Some(payout_data)) => {
let lookup_key = vault::Vault::store_payout_method_data_in_locker(
state,
payout_token.to_owned(),
payout_method,
Some(customer_id.to_owned()),
merchant_key_store,
)
.await?;
// Update payout_token in payout_attempt table
if payout_token.is_none() {
let updated_payout_attempt = storage::PayoutAttemptUpdate::PayoutTokenUpdate {
payout_token: lookup_key,
};
payout_data.payout_attempt = db
.update_payout_attempt(
&payout_data.payout_attempt,
updated_payout_attempt,
&payout_data.payouts,
storage_scheme,
)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Error updating token in payout attempt")?;
}
Ok(Some(payout_method.clone()))
}
// Ignore if nothing is passed
_ => Ok(None),
}
}
pub fn should_create_connector_transfer_method(
payout_data: &PayoutData,
connector_data: &api::ConnectorData,
) -> RouterResult<Option<String>> {
let connector_transfer_method_id = payout_data.payment_method.as_ref().and_then(|pm| {
let common_mandate_reference = pm
.get_common_mandate_reference()
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("unable to deserialize connector mandate details")
.ok()?;
connector_data
.merchant_connector_id
.as_ref()
.and_then(|merchant_connector_id| {
common_mandate_reference
.payouts
.and_then(|payouts_mandate_reference| {
payouts_mandate_reference
.get(merchant_connector_id)
.and_then(|payouts_mandate_reference_record| {
payouts_mandate_reference_record.transfer_method_id.clone()
})
})
})
});
Ok(connector_transfer_method_id)
}
pub async fn fetch_payout_method_data(
state: &SessionState,
payout_data: &mut PayoutData,
connector_data: &api::ConnectorData,
platform: &domain::Platform,
) -> RouterResult<()> {
let connector_transfer_method_id =
should_create_connector_transfer_method(payout_data, connector_data)?;
if connector_transfer_method_id.is_some() {
logger::info!("Using stored transfer_method_id, skipping payout_method_data fetch");
} else {
let customer_id = payout_data
.payouts
.customer_id
.clone()
.get_required_value("customer_id")?;
let payout_method_data_clone = payout_data.payout_method_data.clone();
let payout_token = payout_data.payout_attempt.payout_token.clone();
let merchant_id = payout_data.payout_attempt.merchant_id.clone();
let payout_type = payout_data.payouts.payout_type;
let payout_method_data = make_payout_method_data(
state,
payout_method_data_clone.as_ref(),
payout_token.as_deref(),
&customer_id,
&merchant_id,
payout_type,
platform.get_processor().get_key_store(),
Some(payout_data),
platform.get_processor().get_account().storage_scheme,
)
.await?
.get_required_value("payout_method_data")?;
payout_data.payout_method_data = Some(payout_method_data);
}
Ok(())
}
#[cfg(feature = "v1")]
pub async fn save_payout_data_to_locker(
state: &SessionState,
payout_data: &mut PayoutData,
customer_id: &id_type::CustomerId,
payout_method_data: &api::PayoutMethodData,
connector_mandate_details: Option<serde_json::Value>,
platform: &domain::Platform,
) -> RouterResult<()> {
let mut pm_id: Option<String> = None;
let payouts = &payout_data.payouts;
let key_manager_state = state.into();
let (mut locker_req, card_details, bank_details, wallet_details, payment_method_type) =
match payout_method_data {
payouts::PayoutMethodData::Card(card) => {
let card_detail = api::CardDetail {
card_number: card.card_number.to_owned(),
card_holder_name: card.card_holder_name.to_owned(),
card_exp_month: card.expiry_month.to_owned(),
card_exp_year: card.expiry_year.to_owned(),
card_cvc: None,
nick_name: None,
card_issuing_country: None,
card_issuing_country_code: None,
card_network: None,
card_issuer: None,
card_type: None,
};
let payload = StoreLockerReq::LockerCard(StoreCardReq {
merchant_id: platform.get_processor().get_account().get_id().clone(),
merchant_customer_id: customer_id.to_owned(),
card: Card {
card_number: card.card_number.to_owned(),
name_on_card: card.card_holder_name.to_owned(),
card_exp_month: card.expiry_month.to_owned(),
card_exp_year: card.expiry_year.to_owned(),
card_brand: None,
card_isin: None,
nick_name: None,
},
requestor_card_reference: None,
ttl: state.conf.locker.ttl_for_storage_in_secs,
});
(
payload,
Some(card_detail),
None,
None,
api_enums::PaymentMethodType::Debit,
)
}
_ => {
let key = platform
.get_processor()
.get_key_store()
.key
.get_inner()
.peek();
let key_manager_state: KeyManagerState = state.into();
let enc_data = async {
serde_json::to_value(payout_method_data.to_owned())
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Unable to encode payout method data")
.ok()
.map(|v| {
let secret: Secret<String> = Secret::new(v.to_string());
secret
})
.async_lift(|inner| async {
crypto_operation(
&key_manager_state,
type_name!(storage::PaymentMethod),
CryptoOperation::EncryptOptional(inner),
Identifier::Merchant(
platform.get_processor().get_key_store().merchant_id.clone(),
),
key,
)
.await
.and_then(|val| val.try_into_optionaloperation())
})
.await
}
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed to encrypt payout method data")?
.map(Encryption::from)
.map(|e| e.into_inner())
.map_or(Err(errors::ApiErrorResponse::InternalServerError), |e| {
Ok(hex::encode(e.peek()))
})?;
let payload = StoreLockerReq::LockerGeneric(StoreGenericReq {
merchant_id: platform.get_processor().get_account().get_id().to_owned(),
merchant_customer_id: customer_id.to_owned(),
enc_data,
ttl: state.conf.locker.ttl_for_storage_in_secs,
});
match payout_method_data {
payouts::PayoutMethodData::Bank(bank) => (
payload,
None,
Some(bank.to_owned()),
None,
api_enums::PaymentMethodType::foreign_from(bank),
),
payouts::PayoutMethodData::Wallet(wallet) => (
payload,
None,
None,
Some(wallet.to_owned()),
api_enums::PaymentMethodType::foreign_from(wallet),
),
payouts::PayoutMethodData::Card(_)
| payouts::PayoutMethodData::BankRedirect(_)
| payouts::PayoutMethodData::Passthrough(_) => {
Err(errors::ApiErrorResponse::InternalServerError)?
}
}
}
};
// Store payout method in locker
let stored_resp = cards::add_card_to_vault(state, &locker_req, customer_id)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)?;
let db = &*state.store;
// Handle duplicates
let (should_insert_in_pm_table, metadata_update) = match stored_resp.duplication_check {
// Check if equivalent entry exists in payment_methods
Some(duplication_check) => {
let locker_ref = stored_resp.card_reference.clone();
// Use locker ref as payment_method_id
let existing_pm_by_pmid = db
.find_payment_method(
platform.get_processor().get_key_store(),
&locker_ref,
platform.get_processor().get_account().storage_scheme,
)
.await;
match existing_pm_by_pmid {
// If found, update locker's metadata [DELETE + INSERT OP], don't insert in payment_method's table
Ok(pm) => {
pm_id = Some(pm.payment_method_id.clone());
(
false,
if duplication_check == DataDuplicationCheck::MetaDataChanged {
Some(pm.clone())
} else {
None
},
)
}
// If not found, use locker ref as locker_id
Err(err) => {
if err.current_context().is_db_not_found() {
match db
.find_payment_method_by_locker_id(
platform.get_processor().get_key_store(),
&locker_ref,
platform.get_processor().get_account().storage_scheme,
)
.await
{
// If found, update locker's metadata [DELETE + INSERT OP], don't insert in payment_methods table
Ok(pm) => {
pm_id = Some(pm.payment_method_id.clone());
(
false,
if duplication_check == DataDuplicationCheck::MetaDataChanged {
Some(pm.clone())
} else {
None
},
)
}
Err(err) => {
// If not found, update locker's metadata [DELETE + INSERT OP], and insert in payment_methods table
if err.current_context().is_db_not_found() {
(true, None)
// Misc. DB errors
} else {
Err(err)
.change_context(
errors::ApiErrorResponse::InternalServerError,
)
.attach_printable(
"DB failures while finding payment method by locker ID",
)?
}
}
}
// Misc. DB errors
} else {
Err(err)
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("DB failures while finding payment method by pm ID")?
}
}
}
}
// Not duplicate, should be inserted in payment_methods table
None => (true, None),
};
// Form payment method entry and card's metadata whenever insertion or metadata update is required
let (card_details_encrypted, new_payment_method) =
if let (api::PayoutMethodData::Card(_), true, _)
| (api::PayoutMethodData::Card(_), _, Some(_)) = (
payout_method_data,
should_insert_in_pm_table,
metadata_update.as_ref(),
) {
// Fetch card info from db
let card_isin = card_details.as_ref().map(|c| c.card_number.get_card_isin());
let mut payment_method = api::PaymentMethodCreate {
payment_method: Some(api_enums::PaymentMethod::foreign_from(payout_method_data)),
payment_method_type: Some(payment_method_type),
payment_method_issuer: None,
payment_method_issuer_code: None,
bank_transfer: None,
card: card_details.clone(),
wallet: None,
metadata: None,
customer_id: Some(customer_id.to_owned()),
card_network: None,
client_secret: None,
payment_method_data: None,
billing: None,
connector_mandate_details: None,
network_transaction_id: None,
};
let pm_data = card_isin
.clone()
.async_and_then(|card_isin| async move {
db.get_card_info(&card_isin)
.await
.map_err(|error| services::logger::warn!(card_info_error=?error))
.ok()
})
.await
.flatten()
.map(|card_info| {
payment_method
.payment_method_issuer
.clone_from(&card_info.card_issuer);
payment_method.card_network =
card_info.card_network.clone().map(|cn| cn.to_string());
api::payment_methods::PaymentMethodsData::Card(
api::payment_methods::CardDetailsPaymentMethod {
last4_digits: card_details.as_ref().map(|c| c.card_number.get_last4()),
issuer_country: card_info.card_issuing_country,
issuer_country_code: card_info.country_code,
expiry_month: card_details.as_ref().map(|c| c.card_exp_month.clone()),
expiry_year: card_details.as_ref().map(|c| c.card_exp_year.clone()),
nick_name: card_details.as_ref().and_then(|c| c.nick_name.clone()),
card_holder_name: card_details
.as_ref()
.and_then(|c| c.card_holder_name.clone()),
card_isin: card_isin.clone(),
card_issuer: card_info.card_issuer,
card_network: card_info.card_network,
card_type: card_info.card_type,
saved_to_locker: true,
co_badged_card_data: None,
},
)
})
.unwrap_or_else(|| {
api::payment_methods::PaymentMethodsData::Card(
api::payment_methods::CardDetailsPaymentMethod {
last4_digits: card_details.as_ref().map(|c| c.card_number.get_last4()),
issuer_country: None,
issuer_country_code: None,
expiry_month: card_details.as_ref().map(|c| c.card_exp_month.clone()),
expiry_year: card_details.as_ref().map(|c| c.card_exp_year.clone()),
nick_name: card_details.as_ref().and_then(|c| c.nick_name.clone()),
card_holder_name: card_details
.as_ref()
.and_then(|c| c.card_holder_name.clone()),
card_isin: card_isin.clone(),
card_issuer: None,
card_network: None,
card_type: None,
saved_to_locker: true,
co_badged_card_data: None,
},
)
});
(
Some(
cards::create_encrypted_data(
&key_manager_state,
platform.get_processor().get_key_store(),
pm_data,
)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Unable to encrypt customer details")?,
),
payment_method,
)
} else {
(
None,
api::PaymentMethodCreate {
payment_method: Some(api_enums::PaymentMethod::foreign_from(
payout_method_data,
)),
payment_method_type: Some(payment_method_type),
payment_method_issuer: None,
payment_method_issuer_code: None,
bank_transfer: bank_details,
card: None,
wallet: wallet_details,
metadata: None,
customer_id: Some(customer_id.to_owned()),
card_network: None,
client_secret: None,
payment_method_data: None,
billing: None,
connector_mandate_details: None,
network_transaction_id: None,
},
)
};
let payment_method_billing_address = payout_data
.billing_address
.clone()
.async_map(|billing_addr| async {
cards::create_encrypted_data(
&key_manager_state,
platform.get_processor().get_key_store(),
billing_addr,
)
.await
})
.await
.transpose()
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Unable to encrypt billing address")?;
// Insert new entry in payment_methods table
if should_insert_in_pm_table {
let payment_method_id = common_utils::generate_id(consts::ID_LENGTH, "pm");
payout_data.payment_method = Some(
cards::PmCards {
state,
provider: platform.get_provider(),
}
.create_payment_method(
&new_payment_method,
customer_id,
&payment_method_id,
Some(stored_resp.card_reference.clone()),
platform.get_processor().get_account().get_id(),
None,
None,
card_details_encrypted.clone(),
connector_mandate_details,
None,
None,
payment_method_billing_address,
None,
None,
None,
None,
Default::default(),
)
.await?,
);
}
/* 1. Delete from locker
* 2. Create new entry in locker
* 3. Handle creation response from locker
* 4. Update card's metadata in payment_methods table
*/
if let Some(existing_pm) = metadata_update {
let card_reference = &existing_pm
.locker_id
.clone()
.unwrap_or(existing_pm.payment_method_id.clone());
// Delete from locker
cards::delete_card_from_vault(
state,
customer_id,
platform.get_processor().get_account().get_id(),
card_reference,
)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable(
"Failed to delete PMD from locker as a part of metadata update operation",
)?;
locker_req.update_requestor_card_reference(Some(card_reference.to_string()));
// Store in locker
let stored_resp = cards::add_card_to_vault(state, &locker_req, customer_id)
.await
.change_context(errors::ApiErrorResponse::InternalServerError);
// Check if locker operation was successful or not, if not, delete the entry from payment_methods table
if let Err(err) = stored_resp {
logger::error!(vault_err=?err);
db.delete_payment_method_by_merchant_id_payment_method_id(
platform.get_processor().get_key_store(),
platform.get_processor().get_account().get_id(),
&existing_pm.payment_method_id,
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentMethodNotFound)?;
Err(errors::ApiErrorResponse::InternalServerError).attach_printable(
"Failed to insert PMD from locker as a part of metadata update operation",
)?
};
// Update card's metadata in payment_methods table
let pm_update = storage::PaymentMethodUpdate::PaymentMethodDataUpdate {
payment_method_data: card_details_encrypted.map(Into::into),
last_modified_by: None,
};
payout_data.payment_method = Some(
db.update_payment_method(
platform.get_processor().get_key_store(),
existing_pm,
pm_update,
platform.get_processor().get_account().storage_scheme,
)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed to add payment method in db")?,
);
};
// Store card_reference in payouts table
let payout_method_id = match &payout_data.payment_method {
Some(pm) => pm.payment_method_id.clone(),
None => {
if let Some(id) = pm_id {
id
} else {
Err(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Payment method was not found")?
}
}
};
let updated_payout = storage::PayoutsUpdate::PayoutMethodIdUpdate { payout_method_id };
payout_data.payouts = db
.update_payout(
payouts,
updated_payout,
&payout_data.payout_attempt,
platform.get_processor().get_account().storage_scheme,
)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Error updating payouts in saved payout method")?;
Ok(())
}
#[cfg(feature = "v2")]
pub async fn save_payout_data_to_locker(
_state: &SessionState,
_payout_data: &mut PayoutData,
_customer_id: &id_type::CustomerId,
_payout_method_data: &api::PayoutMethodData,
_connector_mandate_details: Option<serde_json::Value>,
_platform: &domain::Platform,
) -> RouterResult<()> {
todo!()
}
#[cfg(feature = "v2")]
pub(super) async fn get_or_create_customer_details(
_state: &SessionState,
_customer_details: &CustomerDetails,
_merchant_context: &domain::Platform,
) -> RouterResult<Option<domain::Customer>> {
todo!()
}
#[cfg(feature = "v1")]
pub(super) async fn get_or_create_customer_details(
state: &SessionState,
customer_details: &CustomerDetails,
platform: &domain::Platform,
) -> RouterResult<Option<domain::Customer>> {
let db: &dyn StorageInterface = &*state.store;
// Create customer_id if not passed in request
let customer_id = customer_details
.customer_id
.clone()
.unwrap_or_else(generate_customer_id_of_default_length);
let merchant_id = platform.get_processor().get_account().get_id();
let key = platform
.get_processor()
.get_key_store()
.key
.get_inner()
.peek();
match db
.find_customer_optional_by_customer_id_merchant_id(
&customer_id,
merchant_id,
platform.get_processor().get_key_store(),
platform.get_processor().get_account().storage_scheme,
)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)?
{
// Customer found
Some(customer) => Ok(Some(customer)),
// Customer not found
// create only if atleast one of the fields were provided for customer creation or else throw error
None => {
if customer_details.name.is_some()
|| customer_details.email.is_some()
|| customer_details.phone.is_some()
|| customer_details.phone_country_code.is_some()
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | true |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/payouts/validator.rs | crates/router/src/core/payouts/validator.rs | use std::collections::HashSet;
use actix_web::http::header;
#[cfg(feature = "olap")]
use common_utils::errors::CustomResult;
use common_utils::{
id_type::{self, GenerateId},
validation::validate_domain_against_allowed_domains,
};
use diesel_models::generic_link::PayoutLink;
use error_stack::{report, ResultExt};
use hyperswitch_domain_models::payment_methods::PaymentMethod;
use router_env::{instrument, tracing, which as router_env_which, Env};
use url::Url;
use super::helpers;
#[cfg(feature = "v1")]
use crate::core::payment_methods::cards::get_pm_list_context;
use crate::{
core::{
errors::{self, RouterResult},
utils as core_utils,
},
db::StorageInterface,
errors::StorageError,
routes::SessionState,
types::{api::payouts, domain, storage},
utils,
utils::OptionExt,
};
#[instrument(skip(db))]
pub async fn validate_uniqueness_of_payout_id_against_merchant_id(
db: &dyn StorageInterface,
payout_id: &id_type::PayoutId,
merchant_id: &id_type::MerchantId,
storage_scheme: storage::enums::MerchantStorageScheme,
) -> RouterResult<Option<storage::Payouts>> {
let maybe_payouts = db
.find_optional_payout_by_merchant_id_payout_id(merchant_id, payout_id, storage_scheme)
.await;
match maybe_payouts {
Err(err) => {
let storage_err = err.current_context();
match storage_err {
StorageError::ValueNotFound(_) => Ok(None),
_ => Err(err
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed while finding payout_attempt, database error")),
}
}
Ok(payout) => Ok(payout),
}
}
#[cfg(feature = "v2")]
pub async fn validate_create_request(
_state: &SessionState,
_platform: &domain::Platform,
_req: &payouts::PayoutCreateRequest,
) -> RouterResult<(
String,
Option<payouts::PayoutMethodData>,
String,
Option<domain::Customer>,
Option<PaymentMethod>,
)> {
todo!()
}
/// Validates the request on below checks
/// - merchant_id passed is same as the one in merchant_account table
/// - payout_id is unique against merchant_id
/// - payout_token provided is legitimate
#[cfg(feature = "v1")]
pub async fn validate_create_request(
state: &SessionState,
platform: &domain::Platform,
req: &payouts::PayoutCreateRequest,
) -> RouterResult<(
id_type::PayoutId,
Option<payouts::PayoutMethodData>,
id_type::ProfileId,
Option<domain::Customer>,
Option<PaymentMethod>,
)> {
if req.payout_method_id.is_some() && req.confirm != Some(true) {
return Err(report!(errors::ApiErrorResponse::InvalidRequestData {
message: "Confirm must be true for recurring payouts".to_string(),
}));
}
let merchant_id = platform.get_processor().get_account().get_id();
if let Some(payout_link) = &req.payout_link {
if *payout_link {
validate_payout_link_request(req)?;
}
};
// Merchant ID
let predicate = req.merchant_id.as_ref().map(|mid| mid != merchant_id);
utils::when(predicate.unwrap_or(false), || {
Err(report!(errors::ApiErrorResponse::InvalidDataFormat {
field_name: "merchant_id".to_string(),
expected_format: "merchant_id from merchant account".to_string(),
})
.attach_printable("invalid merchant_id in request"))
})?;
// Payout ID
let db: &dyn StorageInterface = &*state.store;
let payout_id = match req.payout_id.as_ref() {
Some(provided_payout_id) => provided_payout_id.clone(),
None => id_type::PayoutId::generate(),
};
match validate_uniqueness_of_payout_id_against_merchant_id(
db,
&payout_id,
merchant_id,
platform.get_processor().get_account().storage_scheme,
)
.await
.attach_printable_lazy(|| {
format!(
"Unique violation while checking payout_id: {payout_id:?} against merchant_id: {merchant_id:?}"
)
})? {
Some(_) => Err(report!(errors::ApiErrorResponse::DuplicatePayout {
payout_id: payout_id.clone()
})),
None => Ok(()),
}?;
// Fetch customer details (merge of loose fields + customer object) and create DB entry
let customer_in_request = helpers::get_customer_details_from_request(req);
let customer = if customer_in_request.customer_id.is_some()
|| customer_in_request.name.is_some()
|| customer_in_request.email.is_some()
|| customer_in_request.phone.is_some()
|| customer_in_request.phone_country_code.is_some()
{
helpers::get_or_create_customer_details(state, &customer_in_request, platform).await?
} else {
None
};
#[cfg(feature = "v1")]
let profile_id = core_utils::get_profile_id_from_business_details(
req.business_country,
req.business_label.as_ref(),
platform.get_processor(),
req.profile_id.as_ref(),
&*state.store,
false,
)
.await?;
#[cfg(feature = "v2")]
// Profile id will be mandatory in v2 in the request / headers
let profile_id = req
.profile_id
.clone()
.ok_or(errors::ApiErrorResponse::MissingRequiredField {
field_name: "profile_id",
})
.attach_printable("Profile id is a mandatory parameter")?;
let payment_method: Option<PaymentMethod> =
match (req.payout_token.as_ref(), req.payout_method_id.clone()) {
(Some(_), Some(_)) => Err(report!(errors::ApiErrorResponse::InvalidRequestData {
message: "Only one of payout_method_id or payout_token should be provided."
.to_string(),
})),
(None, Some(payment_method_id)) => match customer.as_ref() {
Some(customer) => {
let payment_method = db
.find_payment_method(
platform.get_processor().get_key_store(),
&payment_method_id,
platform.get_processor().get_account().storage_scheme,
)
.await
.change_context(errors::ApiErrorResponse::PaymentMethodNotFound)
.attach_printable("Unable to find payment method")?;
utils::when(payment_method.customer_id != customer.customer_id, || {
Err(report!(errors::ApiErrorResponse::InvalidRequestData {
message: "Payment method does not belong to this customer_id".to_string(),
})
.attach_printable(
"customer_id in payment_method does not match with customer_id in request",
))
})?;
Ok(Some(payment_method))
}
None => Err(report!(errors::ApiErrorResponse::MissingRequiredField {
field_name: "customer_id when payment_method_id is passed",
})),
},
_ => Ok(None),
}?;
// payout_token
let payout_method_data = match (
req.payout_token.as_ref(),
customer.as_ref(),
payment_method.as_ref(),
) {
(Some(_), None, _) => Err(report!(errors::ApiErrorResponse::MissingRequiredField {
field_name: "customer or customer_id when payout_token is provided"
})),
(Some(payout_token), Some(customer), _) => {
helpers::make_payout_method_data(
state,
req.payout_method_data.as_ref(),
Some(payout_token),
&customer.customer_id,
platform.get_processor().get_account().get_id(),
req.payout_type,
platform.get_processor().get_key_store(),
None,
platform.get_processor().get_account().storage_scheme,
)
.await
}
(_, Some(_), Some(payment_method)) => {
// Check if we have a stored transfer_method_id first
if payment_method
.get_common_mandate_reference()
.ok()
.and_then(|common_mandate_ref| common_mandate_ref.payouts)
.map(|payouts_mandate_ref| !payouts_mandate_ref.0.is_empty())
.unwrap_or(false)
{
Ok(None)
} else {
// No transfer_method_id available, proceed with vault fetch for raw card details
match get_pm_list_context(
state,
payment_method
.payment_method
.as_ref()
.get_required_value("payment_method_id")?,
platform.get_processor().get_key_store(),
payment_method,
None,
false,
true,
platform.get_provider(),
)
.await?
{
Some(pm) => match (pm.card_details, pm.bank_transfer_details) {
(Some(card), _) => Ok(Some(payouts::PayoutMethodData::Card(
api_models::payouts::CardPayout {
card_number: card.card_number.get_required_value("card_number")?,
card_holder_name: card.card_holder_name,
expiry_month: card
.expiry_month
.get_required_value("expiry_month")?,
expiry_year: card.expiry_year.get_required_value("expiry_year")?,
card_network: card.card_network.clone(),
},
))),
(_, Some(bank)) => Ok(Some(payouts::PayoutMethodData::Bank(bank))),
_ => Ok(None),
},
None => Ok(None),
}
}
}
_ => Ok(None),
}?;
Ok((
payout_id,
payout_method_data,
profile_id,
customer,
payment_method,
))
}
pub fn validate_payout_link_request(
req: &payouts::PayoutCreateRequest,
) -> Result<(), errors::ApiErrorResponse> {
if req.confirm.unwrap_or(false) {
return Err(errors::ApiErrorResponse::InvalidRequestData {
message: "cannot confirm a payout while creating a payout link".to_string(),
});
}
if req.customer_id.is_none() {
return Err(errors::ApiErrorResponse::MissingRequiredField {
field_name: "customer or customer_id when payout_link is true",
});
}
Ok(())
}
#[cfg(feature = "olap")]
pub(super) fn validate_payout_list_request(
req: &payouts::PayoutListConstraints,
) -> CustomResult<(), errors::ApiErrorResponse> {
use common_utils::consts::PAYOUTS_LIST_MAX_LIMIT_GET;
utils::when(
req.limit > PAYOUTS_LIST_MAX_LIMIT_GET || req.limit < 1,
|| {
Err(errors::ApiErrorResponse::InvalidRequestData {
message: format!("limit should be in between 1 and {PAYOUTS_LIST_MAX_LIMIT_GET}"),
})
},
)?;
Ok(())
}
#[cfg(feature = "olap")]
pub(super) fn validate_payout_list_request_for_joins(
limit: u32,
) -> CustomResult<(), errors::ApiErrorResponse> {
use common_utils::consts::PAYOUTS_LIST_MAX_LIMIT_POST;
utils::when(!(1..=PAYOUTS_LIST_MAX_LIMIT_POST).contains(&limit), || {
Err(errors::ApiErrorResponse::InvalidRequestData {
message: format!("limit should be in between 1 and {PAYOUTS_LIST_MAX_LIMIT_POST}"),
})
})?;
Ok(())
}
pub fn validate_payout_link_render_request_and_get_allowed_domains(
request_headers: &header::HeaderMap,
payout_link: &PayoutLink,
) -> RouterResult<HashSet<String>> {
let link_id = payout_link.link_id.to_owned();
let link_data = payout_link.link_data.to_owned();
let is_test_mode_enabled = link_data.test_mode.unwrap_or(false);
match (router_env_which(), is_test_mode_enabled) {
// Throw error in case test_mode was enabled in production
(Env::Production, true) => Err(report!(errors::ApiErrorResponse::LinkConfigurationError {
message: "test_mode cannot be true for rendering payout_links in production"
.to_string()
})),
// Skip all validations when test mode is enabled in non prod env
(_, true) => Ok(HashSet::new()),
// Otherwise, perform validations
(_, false) => {
// Fetch destination is "iframe"
match request_headers.get("sec-fetch-dest").and_then(|v| v.to_str().ok()) {
Some("iframe") => Ok(()),
Some(requestor) => Err(report!(errors::ApiErrorResponse::AccessForbidden {
resource: "payout_link".to_string(),
}))
.attach_printable_lazy(|| {
format!(
"Access to payout_link [{link_id}] is forbidden when requested through {requestor}",
)
}),
None => Err(report!(errors::ApiErrorResponse::AccessForbidden {
resource: "payout_link".to_string(),
}))
.attach_printable_lazy(|| {
format!(
"Access to payout_link [{link_id}] is forbidden when sec-fetch-dest is not present in request headers",
)
}),
}?;
// Validate origin / referer
let domain_in_req = {
let origin_or_referer = request_headers
.get("origin")
.or_else(|| request_headers.get("referer"))
.and_then(|v| v.to_str().ok())
.ok_or_else(|| {
report!(errors::ApiErrorResponse::AccessForbidden {
resource: "payout_link".to_string(),
})
})
.attach_printable_lazy(|| {
format!(
"Access to payout_link [{link_id}] is forbidden when origin or referer is not present in request headers",
)
})?;
let url = Url::parse(origin_or_referer)
.map_err(|_| {
report!(errors::ApiErrorResponse::AccessForbidden {
resource: "payout_link".to_string(),
})
})
.attach_printable_lazy(|| {
format!("Invalid URL found in request headers {origin_or_referer}")
})?;
url.host_str()
.and_then(|host| url.port().map(|port| format!("{host}:{port}")))
.or_else(|| url.host_str().map(String::from))
.ok_or_else(|| {
report!(errors::ApiErrorResponse::AccessForbidden {
resource: "payout_link".to_string(),
})
})
.attach_printable_lazy(|| {
format!("host or port not found in request headers {url:?}")
})?
};
if validate_domain_against_allowed_domains(
&domain_in_req,
link_data.allowed_domains.clone(),
) {
Ok(link_data.allowed_domains)
} else {
Err(report!(errors::ApiErrorResponse::AccessForbidden {
resource: "payout_link".to_string(),
}))
.attach_printable_lazy(|| {
format!(
"Access to payout_link [{link_id}] is forbidden from requestor - {domain_in_req}",
)
})
}
}
}
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/payouts/transformers.rs | crates/router/src/core/payouts/transformers.rs | use std::collections::HashMap;
use common_utils::link_utils::EnabledPaymentMethod;
#[cfg(all(feature = "v1", feature = "olap"))]
use crate::types::transformers::ForeignInto;
#[cfg(feature = "olap")]
use crate::types::{api::payments, domain, storage};
use crate::{
settings::PayoutRequiredFields,
types::{api, transformers::ForeignFrom},
};
#[cfg(all(feature = "v2", feature = "olap"))]
impl
ForeignFrom<(
storage::Payouts,
storage::PayoutAttempt,
Option<domain::Customer>,
Option<payments::Address>,
)> for api::PayoutCreateResponse
{
fn foreign_from(
item: (
storage::Payouts,
storage::PayoutAttempt,
Option<domain::Customer>,
Option<payments::Address>,
),
) -> Self {
todo!()
}
}
#[cfg(all(feature = "v1", feature = "olap"))]
impl
ForeignFrom<(
storage::Payouts,
storage::PayoutAttempt,
Option<domain::Customer>,
Option<payments::Address>,
)> for api::PayoutCreateResponse
{
fn foreign_from(
item: (
storage::Payouts,
storage::PayoutAttempt,
Option<domain::Customer>,
Option<payments::Address>,
),
) -> Self {
let (payout, payout_attempt, customer, address) = item;
let attempt = api::PayoutAttemptResponse {
attempt_id: payout_attempt.payout_attempt_id,
status: payout_attempt.status,
amount: payout.amount,
currency: Some(payout.destination_currency),
connector: payout_attempt.connector.clone(),
error_code: payout_attempt.error_code.clone(),
error_message: payout_attempt.error_message.clone(),
payment_method: payout.payout_type,
payout_method_type: None,
connector_transaction_id: payout_attempt.connector_payout_id,
cancellation_reason: None,
unified_code: None,
unified_message: None,
};
Self {
payout_id: payout.payout_id,
merchant_id: payout.merchant_id,
merchant_connector_id: payout_attempt.merchant_connector_id,
merchant_order_reference_id: payout_attempt.merchant_order_reference_id.clone(),
amount: payout.amount,
currency: payout.destination_currency,
connector: payout_attempt.connector,
payout_type: payout.payout_type,
auto_fulfill: payout.auto_fulfill,
customer_id: customer.as_ref().map(|cust| cust.customer_id.clone()),
customer: customer.as_ref().map(|cust| cust.foreign_into()),
return_url: payout.return_url,
business_country: payout_attempt.business_country,
business_label: payout_attempt.business_label,
description: payout.description,
entity_type: payout.entity_type,
recurring: payout.recurring,
metadata: payout.metadata,
status: payout_attempt.status,
error_message: payout_attempt.error_message,
error_code: payout_attempt.error_code,
profile_id: payout.profile_id,
created: Some(payout.created_at),
connector_transaction_id: attempt.connector_transaction_id.clone(),
priority: payout.priority,
billing: address,
payout_method_data: payout_attempt.additional_payout_method_data.map(From::from),
client_secret: None,
payout_link: None,
unified_code: attempt.unified_code.clone(),
unified_message: attempt.unified_message.clone(),
attempts: Some(vec![attempt]),
email: customer
.as_ref()
.and_then(|customer| customer.email.clone()),
name: customer.as_ref().and_then(|customer| customer.name.clone()),
phone: customer
.as_ref()
.and_then(|customer| customer.phone.clone()),
phone_country_code: customer
.as_ref()
.and_then(|customer| customer.phone_country_code.clone()),
payout_method_id: payout.payout_method_id,
}
}
}
#[cfg(feature = "v1")]
impl
ForeignFrom<(
&PayoutRequiredFields,
Vec<EnabledPaymentMethod>,
api::RequiredFieldsOverrideRequest,
)> for Vec<api::PayoutEnabledPaymentMethodsInfo>
{
fn foreign_from(
(payout_required_fields, enabled_payout_methods, value_overrides): (
&PayoutRequiredFields,
Vec<EnabledPaymentMethod>,
api::RequiredFieldsOverrideRequest,
),
) -> Self {
let value_overrides = value_overrides.flat_struct();
enabled_payout_methods
.into_iter()
.map(|enabled_payout_method| {
let payment_method = enabled_payout_method.payment_method;
let payment_method_types_info = enabled_payout_method
.payment_method_types
.into_iter()
.filter_map(|pmt| {
payout_required_fields
.0
.get(&payment_method)
.and_then(|pmt_info| {
pmt_info.0.get(&pmt).map(|connector_fields| {
let mut required_fields = HashMap::new();
for required_field_final in connector_fields.fields.values() {
required_fields.extend(required_field_final.common.clone());
}
for (key, value) in &value_overrides {
required_fields.entry(key.to_string()).and_modify(
|required_field| {
required_field.value =
Some(masking::Secret::new(value.to_string()));
},
);
}
api::PaymentMethodTypeInfo {
payment_method_type: pmt,
required_fields: if required_fields.is_empty() {
None
} else {
Some(required_fields)
},
}
})
})
.or(Some(api::PaymentMethodTypeInfo {
payment_method_type: pmt,
required_fields: None,
}))
})
.collect();
api::PayoutEnabledPaymentMethodsInfo {
payment_method,
payment_method_types_info,
}
})
.collect()
}
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/payouts/retry.rs | crates/router/src/core/payouts/retry.rs | use std::vec::IntoIter;
use common_enums::PayoutRetryType;
use error_stack::ResultExt;
use router_env::{
logger,
tracing::{self, instrument},
};
use super::{call_connector_payout, PayoutData};
use crate::{
consts,
core::{
errors::{self, RouterResult, StorageErrorExt},
payouts,
},
db::StorageInterface,
routes::{self, app, metrics},
types::{api, domain, storage},
utils,
};
#[instrument(skip_all)]
#[allow(clippy::too_many_arguments)]
pub async fn do_gsm_multiple_connector_actions(
state: &app::SessionState,
mut connectors_routing_data: IntoIter<api::ConnectorRoutingData>,
original_connector_data: api::ConnectorData,
payout_data: &mut PayoutData,
platform: &domain::Platform,
) -> RouterResult<()> {
let mut retries = None;
metrics::AUTO_PAYOUT_RETRY_ELIGIBLE_REQUEST_COUNT.add(1, &[]);
let mut connector = original_connector_data;
loop {
let gsm = get_gsm(state, &connector, payout_data).await?;
match get_gsm_decision(gsm) {
common_enums::GsmDecision::Retry => {
retries = get_retries(
state,
retries,
platform.get_processor().get_account().get_id(),
PayoutRetryType::MultiConnector,
)
.await;
if retries.is_none() || retries == Some(0) {
metrics::AUTO_PAYOUT_RETRY_EXHAUSTED_COUNT.add(1, &[]);
logger::info!("retries exhausted for auto_retry payout");
break;
}
if connectors_routing_data.len() == 0 {
logger::info!("connectors exhausted for auto_retry payout");
metrics::AUTO_PAYOUT_RETRY_EXHAUSTED_COUNT.add(1, &[]);
break;
}
connector = super::get_next_connector(&mut connectors_routing_data)?.connector_data;
Box::pin(do_retry(
&state.clone(),
connector.to_owned(),
platform,
payout_data,
))
.await?;
retries = retries.map(|i| i - 1);
}
common_enums::GsmDecision::DoDefault => break,
}
}
Ok(())
}
#[instrument(skip_all)]
#[allow(clippy::too_many_arguments)]
pub async fn do_gsm_single_connector_actions(
state: &app::SessionState,
original_connector_data: api::ConnectorData,
payout_data: &mut PayoutData,
platform: &domain::Platform,
) -> RouterResult<()> {
let mut retries = None;
metrics::AUTO_PAYOUT_RETRY_ELIGIBLE_REQUEST_COUNT.add(1, &[]);
let mut previous_gsm = None; // to compare previous status
loop {
let gsm = get_gsm(state, &original_connector_data, payout_data).await?;
// if the error config is same as previous, we break out of the loop
if gsm == previous_gsm {
break;
}
previous_gsm.clone_from(&gsm);
match get_gsm_decision(gsm) {
common_enums::GsmDecision::Retry => {
retries = get_retries(
state,
retries,
platform.get_processor().get_account().get_id(),
PayoutRetryType::SingleConnector,
)
.await;
if retries.is_none() || retries == Some(0) {
metrics::AUTO_PAYOUT_RETRY_EXHAUSTED_COUNT.add(1, &[]);
logger::info!("retries exhausted for auto_retry payment");
break;
}
Box::pin(do_retry(
&state.clone(),
original_connector_data.to_owned(),
platform,
payout_data,
))
.await?;
retries = retries.map(|i| i - 1);
}
common_enums::GsmDecision::DoDefault => break,
}
}
Ok(())
}
#[instrument(skip_all)]
pub async fn get_retries(
state: &app::SessionState,
retries: Option<i32>,
merchant_id: &common_utils::id_type::MerchantId,
retry_type: PayoutRetryType,
) -> Option<i32> {
match retries {
Some(retries) => Some(retries),
None => {
let key = merchant_id.get_max_auto_single_connector_payout_retries_enabled(retry_type);
let db = &*state.store;
db.find_config_by_key(key.as_str())
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.and_then(|retries_config| {
retries_config
.config
.parse::<i32>()
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Retries config parsing failed")
})
.map_err(|err| {
logger::error!(retries_error=?err);
None::<i32>
})
.ok()
}
}
}
#[instrument(skip_all)]
pub async fn get_gsm(
state: &app::SessionState,
original_connector_data: &api::ConnectorData,
payout_data: &PayoutData,
) -> RouterResult<Option<hyperswitch_domain_models::gsm::GatewayStatusMap>> {
let error_code = payout_data.payout_attempt.error_code.to_owned();
let error_message = payout_data.payout_attempt.error_message.to_owned();
let connector_name = Some(original_connector_data.connector_name.to_string());
Ok(payouts::helpers::get_gsm_record(
state,
error_code,
error_message,
connector_name,
common_utils::consts::PAYOUT_FLOW_STR,
consts::DEFAULT_SUBFLOW_STR,
)
.await)
}
#[instrument(skip_all)]
pub fn get_gsm_decision(
option_gsm: Option<hyperswitch_domain_models::gsm::GatewayStatusMap>,
) -> common_enums::GsmDecision {
let option_gsm_decision = option_gsm.map(|gsm| gsm.feature_data.get_decision());
if option_gsm_decision.is_some() {
metrics::AUTO_PAYOUT_RETRY_GSM_MATCH_COUNT.add(1, &[]);
}
option_gsm_decision.unwrap_or_default()
}
#[allow(clippy::too_many_arguments)]
#[instrument(skip_all)]
pub async fn do_retry(
state: &routes::SessionState,
connector: api::ConnectorData,
platform: &domain::Platform,
payout_data: &mut PayoutData,
) -> RouterResult<()> {
metrics::AUTO_RETRY_PAYOUT_COUNT.add(1, &[]);
modify_trackers(state, &connector, platform, payout_data).await?;
Box::pin(call_connector_payout(
state,
platform,
&connector,
payout_data,
))
.await
}
#[instrument(skip_all)]
pub async fn modify_trackers(
state: &routes::SessionState,
connector: &api::ConnectorData,
platform: &domain::Platform,
payout_data: &mut PayoutData,
) -> RouterResult<()> {
let new_attempt_count = payout_data.payouts.attempt_count + 1;
let db = &*state.store;
// update payout table's attempt count
let payouts = payout_data.payouts.to_owned();
let updated_payouts = storage::PayoutsUpdate::AttemptCountUpdate {
attempt_count: new_attempt_count,
};
let payout_id = payouts.payout_id.clone();
payout_data.payouts = db
.update_payout(
&payout_data.payouts,
updated_payouts,
&payout_data.payout_attempt,
platform.get_processor().get_account().storage_scheme,
)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Error updating payouts")?;
let payout_attempt_id = utils::get_payout_attempt_id(
payout_id.get_string_repr(),
payout_data.payouts.attempt_count,
);
let payout_attempt_req = storage::PayoutAttemptNew {
payout_attempt_id: payout_attempt_id.to_string(),
payout_id: payout_id.to_owned(),
merchant_order_reference_id: payout_data
.payout_attempt
.merchant_order_reference_id
.clone(),
customer_id: payout_data.payout_attempt.customer_id.to_owned(),
connector: Some(connector.connector_name.to_string()),
merchant_id: payout_data.payout_attempt.merchant_id.to_owned(),
address_id: payout_data.payout_attempt.address_id.to_owned(),
business_country: payout_data.payout_attempt.business_country.to_owned(),
business_label: payout_data.payout_attempt.business_label.to_owned(),
payout_token: payout_data.payout_attempt.payout_token.to_owned(),
profile_id: payout_data.payout_attempt.profile_id.to_owned(),
connector_payout_id: None,
status: common_enums::PayoutStatus::default(),
is_eligible: None,
error_message: None,
error_code: None,
created_at: common_utils::date_time::now(),
last_modified_at: common_utils::date_time::now(),
merchant_connector_id: None,
routing_info: None,
unified_code: None,
unified_message: None,
additional_payout_method_data: payout_data
.payout_attempt
.additional_payout_method_data
.to_owned(),
payout_connector_metadata: None,
};
payout_data.payout_attempt = db
.insert_payout_attempt(
payout_attempt_req,
&payouts,
platform.get_processor().get_account().storage_scheme,
)
.await
.to_duplicate_response(errors::ApiErrorResponse::DuplicatePayout { payout_id })
.attach_printable("Error inserting payouts in db")?;
payout_data.merchant_connector_account = None;
Ok(())
}
pub async fn config_should_call_gsm_payout(
db: &dyn StorageInterface,
merchant_id: &common_utils::id_type::MerchantId,
retry_type: PayoutRetryType,
) -> bool {
let key = merchant_id.get_should_call_gsm_payout_key(retry_type);
let config = db
.find_config_by_key_unwrap_or(key.as_str(), Some("false".to_string()))
.await;
match config {
Ok(conf) => conf.config == "true",
Err(error) => {
logger::error!(?error);
false
}
}
}
pub trait GsmValidation {
// TODO : move this function to appropriate place later.
fn should_call_gsm(&self) -> bool;
}
impl GsmValidation for PayoutData {
#[inline(always)]
fn should_call_gsm(&self) -> bool {
match self.payout_attempt.status {
common_enums::PayoutStatus::Success
| common_enums::PayoutStatus::RequiresConfirmation
| common_enums::PayoutStatus::Cancelled
| common_enums::PayoutStatus::Pending
| common_enums::PayoutStatus::Initiated
| common_enums::PayoutStatus::Reversed
| common_enums::PayoutStatus::Expired
| common_enums::PayoutStatus::Ineligible
| common_enums::PayoutStatus::RequiresCreation
| common_enums::PayoutStatus::RequiresPayoutMethodData
| common_enums::PayoutStatus::RequiresVendorAccountCreation
| common_enums::PayoutStatus::RequiresFulfillment => false,
common_enums::PayoutStatus::Failed => true,
}
}
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/routing/helpers.rs | crates/router/src/core/routing/helpers.rs | //! Analysis for usage of all helper functions for use case of routing
//!
//! Functions that are used to perform the retrieval of merchant's
//! routing dict, configs, defaults
use std::fmt::Debug;
#[cfg(all(feature = "dynamic_routing", feature = "v1"))]
use std::str::FromStr;
#[cfg(all(feature = "dynamic_routing", feature = "v1"))]
use std::sync::Arc;
#[cfg(feature = "v1")]
use api_models::open_router;
use api_models::routing as routing_types;
#[cfg(all(feature = "dynamic_routing", feature = "v1"))]
use common_utils::ext_traits::ValueExt;
use common_utils::{ext_traits::Encode, id_type};
use diesel_models::configs;
#[cfg(all(feature = "v1", feature = "dynamic_routing"))]
use diesel_models::dynamic_routing_stats::{DynamicRoutingStatsNew, DynamicRoutingStatsUpdate};
#[cfg(all(feature = "dynamic_routing", feature = "v1"))]
use diesel_models::routing_algorithm;
use error_stack::ResultExt;
#[cfg(all(feature = "dynamic_routing", feature = "v1"))]
use external_services::grpc_client::dynamic_routing::{
contract_routing_client::ContractBasedDynamicRouting,
elimination_based_client::EliminationBasedRouting,
success_rate_client::SuccessBasedDynamicRouting,
};
#[cfg(all(feature = "v1", feature = "dynamic_routing"))]
use hyperswitch_domain_models::api::ApplicationResponse;
#[cfg(all(feature = "v1", feature = "dynamic_routing"))]
use hyperswitch_interfaces::events::routing_api_logs as routing_events;
#[cfg(feature = "v1")]
use router_env::logger;
#[cfg(feature = "v1")]
use router_env::{instrument, tracing};
use rustc_hash::FxHashSet;
use storage_impl::redis::cache;
#[cfg(all(feature = "dynamic_routing", feature = "v1"))]
use storage_impl::redis::cache::Cacheable;
#[cfg(all(feature = "dynamic_routing", feature = "v1"))]
use crate::db::errors::StorageErrorExt;
#[cfg(feature = "v2")]
use crate::types::domain::MerchantConnectorAccount;
#[cfg(all(feature = "dynamic_routing", feature = "v1"))]
use crate::types::transformers::ForeignFrom;
use crate::{
core::errors::{self, RouterResult},
db::StorageInterface,
routes::SessionState,
types::{domain, storage},
utils::StringExt,
};
#[cfg(feature = "v1")]
use crate::{
core::payments::{
routing::utils::{self as routing_utils, DecisionEngineApiHandler},
OperationSessionGetters, OperationSessionSetters,
},
services,
};
#[cfg(all(feature = "dynamic_routing", feature = "v1"))]
use crate::{
core::{metrics as core_metrics, routing},
routes::app::SessionStateInfo,
types::transformers::ForeignInto,
};
pub const SUCCESS_BASED_DYNAMIC_ROUTING_ALGORITHM: &str =
"Success rate based dynamic routing algorithm";
pub const ELIMINATION_BASED_DYNAMIC_ROUTING_ALGORITHM: &str =
"Elimination based dynamic routing algorithm";
pub const CONTRACT_BASED_DYNAMIC_ROUTING_ALGORITHM: &str =
"Contract based dynamic routing algorithm";
pub const DECISION_ENGINE_RULE_CREATE_ENDPOINT: &str = "rule/create";
pub const DECISION_ENGINE_RULE_UPDATE_ENDPOINT: &str = "rule/update";
pub const DECISION_ENGINE_RULE_GET_ENDPOINT: &str = "rule/get";
pub const DECISION_ENGINE_RULE_DELETE_ENDPOINT: &str = "rule/delete";
pub const DECISION_ENGINE_MERCHANT_BASE_ENDPOINT: &str = "merchant-account";
pub const DECISION_ENGINE_MERCHANT_CREATE_ENDPOINT: &str = "merchant-account/create";
/// Provides us with all the configured configs of the Merchant in the ascending time configured
/// manner and chooses the first of them
pub async fn get_merchant_default_config(
db: &dyn StorageInterface,
// Cannot make this as merchant id domain type because, we are passing profile id also here
merchant_id: &str,
transaction_type: &storage::enums::TransactionType,
) -> RouterResult<Vec<routing_types::RoutableConnectorChoice>> {
let key = get_default_config_key(merchant_id, transaction_type);
let maybe_config = db.find_config_by_key(&key).await;
match maybe_config {
Ok(config) => config
.config
.parse_struct("Vec<RoutableConnectors>")
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Merchant default config has invalid structure"),
Err(e) if e.current_context().is_db_not_found() => {
let new_config_conns = Vec::<routing_types::RoutableConnectorChoice>::new();
let serialized = new_config_conns
.encode_to_string_of_json()
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable(
"Error while creating and serializing new merchant default config",
)?;
let new_config = configs::ConfigNew {
key,
config: serialized,
};
db.insert_config(new_config)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Error inserting new default routing config into DB")?;
Ok(new_config_conns)
}
Err(e) => Err(e)
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Error fetching default config for merchant"),
}
}
/// Merchant's already created config can be updated and this change will be reflected
/// in DB as well for the particular updated config
pub async fn update_merchant_default_config(
db: &dyn StorageInterface,
merchant_id: &str,
connectors: Vec<routing_types::RoutableConnectorChoice>,
transaction_type: &storage::enums::TransactionType,
) -> RouterResult<()> {
let key = get_default_config_key(merchant_id, transaction_type);
let config_str = connectors
.encode_to_string_of_json()
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Unable to serialize merchant default routing config during update")?;
let config_update = configs::ConfigUpdate::Update {
config: Some(config_str),
};
db.update_config_by_key(&key, config_update)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Error updating the default routing config in DB")?;
Ok(())
}
pub async fn update_merchant_routing_dictionary(
db: &dyn StorageInterface,
merchant_id: &str,
dictionary: routing_types::RoutingDictionary,
) -> RouterResult<()> {
let key = get_routing_dictionary_key(merchant_id);
let dictionary_str = dictionary
.encode_to_string_of_json()
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Unable to serialize routing dictionary during update")?;
let config_update = configs::ConfigUpdate::Update {
config: Some(dictionary_str),
};
db.update_config_by_key(&key, config_update)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Error saving routing dictionary to DB")?;
Ok(())
}
/// This will help make one of all configured algorithms to be in active state for a particular
/// merchant
#[cfg(feature = "v1")]
pub async fn update_merchant_active_algorithm_ref(
state: &SessionState,
key_store: &domain::MerchantKeyStore,
config_key: cache::CacheKind<'_>,
algorithm_id: routing_types::RoutingAlgorithmRef,
) -> RouterResult<()> {
let ref_value = algorithm_id
.encode_to_value()
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed converting routing algorithm ref to json value")?;
let merchant_account_update = storage::MerchantAccountUpdate::Update {
merchant_name: None,
merchant_details: None,
return_url: None,
webhook_details: None,
sub_merchants_enabled: None,
parent_merchant_id: None,
enable_payment_response_hash: None,
payment_response_hash_key: None,
redirect_to_merchant_with_http_post: None,
publishable_key: None,
locker_id: None,
metadata: None,
routing_algorithm: Some(ref_value),
primary_business_details: None,
intent_fulfillment_time: None,
frm_routing_algorithm: None,
payout_routing_algorithm: None,
default_profile: None,
payment_link_config: None,
pm_collect_link_config: None,
};
let db = &*state.store;
db.update_specific_fields_in_merchant(
&key_store.merchant_id,
merchant_account_update,
key_store,
)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed to update routing algorithm ref in merchant account")?;
cache::redact_from_redis_and_publish(db.get_cache_store().as_ref(), [config_key])
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed to invalidate the config cache")?;
Ok(())
}
#[cfg(feature = "v1")]
pub async fn update_profile_active_algorithm_ref(
db: &dyn StorageInterface,
merchant_key_store: &domain::MerchantKeyStore,
current_business_profile: domain::Profile,
algorithm_id: routing_types::RoutingAlgorithmRef,
transaction_type: &storage::enums::TransactionType,
) -> RouterResult<()> {
let ref_val = algorithm_id
.encode_to_value()
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed to convert routing ref to value")?;
let merchant_id = current_business_profile.merchant_id.clone();
let profile_id = current_business_profile.get_id().to_owned();
let (routing_algorithm, payout_routing_algorithm, three_ds_decision_rule_algorithm) =
match transaction_type {
storage::enums::TransactionType::Payment => (Some(ref_val), None, None),
#[cfg(feature = "payouts")]
storage::enums::TransactionType::Payout => (None, Some(ref_val), None),
storage::enums::TransactionType::ThreeDsAuthentication => (None, None, Some(ref_val)),
};
let business_profile_update = domain::ProfileUpdate::RoutingAlgorithmUpdate {
routing_algorithm,
payout_routing_algorithm,
three_ds_decision_rule_algorithm,
};
db.update_profile_by_profile_id(
merchant_key_store,
current_business_profile,
business_profile_update,
)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed to update routing algorithm ref in business profile")?;
// Invalidate the routing cache for Payments and Payouts transaction types
if !transaction_type.is_three_ds_authentication() {
let routing_cache_key = cache::CacheKind::Routing(
format!(
"routing_config_{}_{}",
merchant_id.get_string_repr(),
profile_id.get_string_repr(),
)
.into(),
);
cache::redact_from_redis_and_publish(db.get_cache_store().as_ref(), [routing_cache_key])
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed to invalidate routing cache")?;
}
Ok(())
}
#[cfg(feature = "v1")]
pub async fn update_business_profile_active_dynamic_algorithm_ref(
db: &dyn StorageInterface,
merchant_key_store: &domain::MerchantKeyStore,
current_business_profile: domain::Profile,
dynamic_routing_algorithm_ref: routing_types::DynamicRoutingAlgorithmRef,
) -> RouterResult<()> {
let ref_val = dynamic_routing_algorithm_ref
.encode_to_value()
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed to convert dynamic routing ref to value")?;
let business_profile_update = domain::ProfileUpdate::DynamicRoutingAlgorithmUpdate {
dynamic_routing_algorithm: Some(ref_val),
};
db.update_profile_by_profile_id(
merchant_key_store,
current_business_profile,
business_profile_update,
)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed to update dynamic routing algorithm ref in business profile")?;
Ok(())
}
#[cfg(feature = "v2")]
#[derive(Clone, Debug)]
pub struct RoutingAlgorithmHelpers<'h> {
pub name_mca_id_set: ConnectNameAndMCAIdForProfile<'h>,
pub name_set: ConnectNameForProfile<'h>,
pub routing_algorithm: &'h routing_types::StaticRoutingAlgorithm,
}
#[cfg(feature = "v1")]
pub enum RoutingDecisionData {
DebitRouting(DebitRoutingDecisionData),
}
#[cfg(feature = "v1")]
pub struct DebitRoutingDecisionData {
pub card_network: common_enums::enums::CardNetwork,
pub debit_routing_result: Option<open_router::DebitRoutingOutput>,
}
#[cfg(feature = "v1")]
impl RoutingDecisionData {
pub fn apply_routing_decision<F, D>(&self, payment_data: &mut D)
where
F: Send + Clone,
D: OperationSessionGetters<F> + OperationSessionSetters<F> + Send + Sync + Clone,
{
match self {
Self::DebitRouting(data) => data.apply_debit_routing_decision(payment_data),
}
}
pub fn get_debit_routing_decision_data(
network: common_enums::enums::CardNetwork,
debit_routing_result: Option<open_router::DebitRoutingOutput>,
) -> Self {
Self::DebitRouting(DebitRoutingDecisionData {
card_network: network,
debit_routing_result,
})
}
}
#[cfg(feature = "v1")]
impl DebitRoutingDecisionData {
pub fn apply_debit_routing_decision<F, D>(&self, payment_data: &mut D)
where
F: Send + Clone,
D: OperationSessionGetters<F> + OperationSessionSetters<F> + Send + Sync + Clone,
{
payment_data.set_card_network(self.card_network.clone());
self.debit_routing_result
.as_ref()
.map(|data| payment_data.set_co_badged_card_data(data));
}
}
#[derive(Clone, Debug)]
pub struct ConnectNameAndMCAIdForProfile<'a>(
pub FxHashSet<(
&'a common_enums::connector_enums::Connector,
id_type::MerchantConnectorAccountId,
)>,
);
#[derive(Clone, Debug)]
pub struct ConnectNameForProfile<'a>(pub FxHashSet<&'a common_enums::connector_enums::Connector>);
#[cfg(feature = "v2")]
impl RoutingAlgorithmHelpers<'_> {
fn connector_choice(
&self,
choice: &routing_types::RoutableConnectorChoice,
) -> RouterResult<()> {
if let Some(ref mca_id) = choice.merchant_connector_id {
let connector_choice = common_enums::connector_enums::Connector::from(choice.connector);
error_stack::ensure!(
self.name_mca_id_set.0.contains(&(&connector_choice, mca_id.clone())),
errors::ApiErrorResponse::InvalidRequestData {
message: format!(
"connector with name '{connector_choice}' and merchant connector account id '{mca_id:?}' not found for the given profile",
)
}
);
} else {
let connector_choice = common_enums::connector_enums::Connector::from(choice.connector);
error_stack::ensure!(
self.name_set.0.contains(&connector_choice),
errors::ApiErrorResponse::InvalidRequestData {
message: format!(
"connector with name '{connector_choice}' not found for the given profile",
)
}
);
};
Ok(())
}
pub fn validate_connectors_in_routing_config(&self) -> RouterResult<()> {
match self.routing_algorithm {
routing_types::StaticRoutingAlgorithm::Single(choice) => {
self.connector_choice(choice)?;
}
routing_types::StaticRoutingAlgorithm::Priority(list) => {
for choice in list {
self.connector_choice(choice)?;
}
}
routing_types::StaticRoutingAlgorithm::VolumeSplit(splits) => {
for split in splits {
self.connector_choice(&split.connector)?;
}
}
routing_types::StaticRoutingAlgorithm::Advanced(program) => {
let check_connector_selection =
|selection: &routing_types::ConnectorSelection| -> RouterResult<()> {
match selection {
routing_types::ConnectorSelection::VolumeSplit(splits) => {
for split in splits {
self.connector_choice(&split.connector)?;
}
}
routing_types::ConnectorSelection::Priority(list) => {
for choice in list {
self.connector_choice(choice)?;
}
}
}
Ok(())
};
check_connector_selection(&program.default_selection)?;
for rule in &program.rules {
check_connector_selection(&rule.connector_selection)?;
}
}
routing_types::StaticRoutingAlgorithm::ThreeDsDecisionRule(_) => {
return Err(errors::ApiErrorResponse::InternalServerError).attach_printable(
"Invalid routing algorithm three_ds decision rule received",
)?;
}
}
Ok(())
}
}
#[cfg(feature = "v1")]
pub async fn validate_connectors_in_routing_config(
state: &SessionState,
key_store: &domain::MerchantKeyStore,
merchant_id: &id_type::MerchantId,
profile_id: &id_type::ProfileId,
routing_algorithm: &routing_types::StaticRoutingAlgorithm,
) -> RouterResult<()> {
let all_mcas = state
.store
.find_merchant_connector_account_by_merchant_id_and_disabled_list(
merchant_id,
true,
key_store,
)
.await
.change_context(errors::ApiErrorResponse::MerchantConnectorAccountNotFound {
id: merchant_id.get_string_repr().to_owned(),
})?;
let name_mca_id_set = all_mcas
.iter()
.filter(|mca| mca.profile_id == *profile_id)
.map(|mca| (&mca.connector_name, mca.get_id()))
.collect::<FxHashSet<_>>();
let name_set = all_mcas
.iter()
.filter(|mca| mca.profile_id == *profile_id)
.map(|mca| &mca.connector_name)
.collect::<FxHashSet<_>>();
let connector_choice = |choice: &routing_types::RoutableConnectorChoice| {
if let Some(ref mca_id) = choice.merchant_connector_id {
error_stack::ensure!(
name_mca_id_set.contains(&(&choice.connector.to_string(), mca_id.clone())),
errors::ApiErrorResponse::InvalidRequestData {
message: format!(
"connector with name '{}' and merchant connector account id '{:?}' not found for the given profile",
choice.connector,
mca_id,
)
}
);
} else {
error_stack::ensure!(
name_set.contains(&choice.connector.to_string()),
errors::ApiErrorResponse::InvalidRequestData {
message: format!(
"connector with name '{}' not found for the given profile",
choice.connector,
)
}
);
}
Ok(())
};
match routing_algorithm {
routing_types::StaticRoutingAlgorithm::Single(choice) => {
connector_choice(choice)?;
}
routing_types::StaticRoutingAlgorithm::Priority(list) => {
for choice in list {
connector_choice(choice)?;
}
}
routing_types::StaticRoutingAlgorithm::VolumeSplit(splits) => {
for split in splits {
connector_choice(&split.connector)?;
}
}
routing_types::StaticRoutingAlgorithm::Advanced(program) => {
let check_connector_selection =
|selection: &routing_types::ConnectorSelection| -> RouterResult<()> {
match selection {
routing_types::ConnectorSelection::VolumeSplit(splits) => {
for split in splits {
connector_choice(&split.connector)?;
}
}
routing_types::ConnectorSelection::Priority(list) => {
for choice in list {
connector_choice(choice)?;
}
}
}
Ok(())
};
check_connector_selection(&program.default_selection)?;
for rule in &program.rules {
check_connector_selection(&rule.connector_selection)?;
}
}
routing_types::StaticRoutingAlgorithm::ThreeDsDecisionRule(_) => {
Err(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Invalid routing algorithm three_ds decision rule received")?
}
}
Ok(())
}
/// Provides the identifier for the specific merchant's routing_dictionary_key
#[inline(always)]
pub fn get_routing_dictionary_key(merchant_id: &str) -> String {
format!("routing_dict_{merchant_id}")
}
/// Provides the identifier for the specific merchant's default_config
#[inline(always)]
pub fn get_default_config_key(
merchant_id: &str,
transaction_type: &storage::enums::TransactionType,
) -> String {
match transaction_type {
storage::enums::TransactionType::Payment => format!("routing_default_{merchant_id}"),
#[cfg(feature = "payouts")]
storage::enums::TransactionType::Payout => format!("routing_default_po_{merchant_id}"),
storage::enums::TransactionType::ThreeDsAuthentication => {
format!("three_ds_authentication_{merchant_id}")
}
}
}
#[cfg(all(feature = "dynamic_routing", feature = "v1"))]
#[async_trait::async_trait]
pub trait DynamicRoutingCache {
async fn get_cached_dynamic_routing_config_for_profile(
state: &SessionState,
key: &str,
) -> Option<Arc<Self>>;
async fn refresh_dynamic_routing_cache<T, F, Fut>(
state: &SessionState,
key: &str,
func: F,
) -> RouterResult<T>
where
F: FnOnce() -> Fut + Send,
T: Cacheable + serde::Serialize + serde::de::DeserializeOwned + Debug + Clone,
Fut: futures::Future<Output = errors::CustomResult<T, errors::StorageError>> + Send;
}
#[cfg(all(feature = "dynamic_routing", feature = "v1"))]
#[async_trait::async_trait]
impl DynamicRoutingCache for routing_types::SuccessBasedRoutingConfig {
async fn get_cached_dynamic_routing_config_for_profile(
state: &SessionState,
key: &str,
) -> Option<Arc<Self>> {
cache::SUCCESS_BASED_DYNAMIC_ALGORITHM_CACHE
.get_val::<Arc<Self>>(cache::CacheKey {
key: key.to_string(),
prefix: state.tenant.redis_key_prefix.clone(),
})
.await
}
async fn refresh_dynamic_routing_cache<T, F, Fut>(
state: &SessionState,
key: &str,
func: F,
) -> RouterResult<T>
where
F: FnOnce() -> Fut + Send,
T: Cacheable + serde::Serialize + serde::de::DeserializeOwned + Debug + Clone,
Fut: futures::Future<Output = errors::CustomResult<T, errors::StorageError>> + Send,
{
cache::get_or_populate_in_memory(
state.store.get_cache_store().as_ref(),
key,
func,
&cache::SUCCESS_BASED_DYNAMIC_ALGORITHM_CACHE,
)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("unable to populate SUCCESS_BASED_DYNAMIC_ALGORITHM_CACHE")
}
}
#[cfg(all(feature = "dynamic_routing", feature = "v1"))]
#[async_trait::async_trait]
impl DynamicRoutingCache for routing_types::ContractBasedRoutingConfig {
async fn get_cached_dynamic_routing_config_for_profile(
state: &SessionState,
key: &str,
) -> Option<Arc<Self>> {
cache::CONTRACT_BASED_DYNAMIC_ALGORITHM_CACHE
.get_val::<Arc<Self>>(cache::CacheKey {
key: key.to_string(),
prefix: state.tenant.redis_key_prefix.clone(),
})
.await
}
async fn refresh_dynamic_routing_cache<T, F, Fut>(
state: &SessionState,
key: &str,
func: F,
) -> RouterResult<T>
where
F: FnOnce() -> Fut + Send,
T: Cacheable + serde::Serialize + serde::de::DeserializeOwned + Debug + Clone,
Fut: futures::Future<Output = errors::CustomResult<T, errors::StorageError>> + Send,
{
cache::get_or_populate_in_memory(
state.store.get_cache_store().as_ref(),
key,
func,
&cache::CONTRACT_BASED_DYNAMIC_ALGORITHM_CACHE,
)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("unable to populate CONTRACT_BASED_DYNAMIC_ALGORITHM_CACHE")
}
}
#[cfg(all(feature = "dynamic_routing", feature = "v1"))]
#[async_trait::async_trait]
impl DynamicRoutingCache for routing_types::EliminationRoutingConfig {
async fn get_cached_dynamic_routing_config_for_profile(
state: &SessionState,
key: &str,
) -> Option<Arc<Self>> {
cache::ELIMINATION_BASED_DYNAMIC_ALGORITHM_CACHE
.get_val::<Arc<Self>>(cache::CacheKey {
key: key.to_string(),
prefix: state.tenant.redis_key_prefix.clone(),
})
.await
}
async fn refresh_dynamic_routing_cache<T, F, Fut>(
state: &SessionState,
key: &str,
func: F,
) -> RouterResult<T>
where
F: FnOnce() -> Fut + Send,
T: Cacheable + serde::Serialize + serde::de::DeserializeOwned + Debug + Clone,
Fut: futures::Future<Output = errors::CustomResult<T, errors::StorageError>> + Send,
{
cache::get_or_populate_in_memory(
state.store.get_cache_store().as_ref(),
key,
func,
&cache::ELIMINATION_BASED_DYNAMIC_ALGORITHM_CACHE,
)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("unable to populate ELIMINATION_BASED_DYNAMIC_ALGORITHM_CACHE")
}
}
/// Cfetch dynamic routing configs
#[cfg(all(feature = "v1", feature = "dynamic_routing"))]
#[instrument(skip_all)]
pub async fn fetch_dynamic_routing_configs<T>(
state: &SessionState,
profile_id: &id_type::ProfileId,
routing_id: id_type::RoutingId,
) -> RouterResult<T>
where
T: serde::de::DeserializeOwned
+ Clone
+ DynamicRoutingCache
+ Cacheable
+ serde::Serialize
+ Debug,
{
let key = format!(
"{}_{}",
profile_id.get_string_repr(),
routing_id.get_string_repr()
);
if let Some(config) =
T::get_cached_dynamic_routing_config_for_profile(state, key.as_str()).await
{
Ok(config.as_ref().clone())
} else {
let func = || async {
let routing_algorithm = state
.store
.find_routing_algorithm_by_profile_id_algorithm_id(profile_id, &routing_id)
.await
.change_context(errors::StorageError::ValueNotFound(
"RoutingAlgorithm".to_string(),
))
.attach_printable("unable to retrieve routing_algorithm for profile from db")?;
let dynamic_routing_config = routing_algorithm
.algorithm_data
.parse_value::<T>("dynamic_routing_config")
.change_context(errors::StorageError::DeserializationFailed)
.attach_printable("unable to parse dynamic_routing_config")?;
Ok(dynamic_routing_config)
};
let dynamic_routing_config =
T::refresh_dynamic_routing_cache(state, key.as_str(), func).await?;
Ok(dynamic_routing_config)
}
}
#[cfg(all(feature = "v1", feature = "dynamic_routing"))]
#[instrument(skip_all)]
pub async fn update_gateway_score_helper_with_open_router(
state: &SessionState,
payment_attempt: &storage::PaymentAttempt,
profile_id: &id_type::ProfileId,
dynamic_routing_algo_ref: routing_types::DynamicRoutingAlgorithmRef,
) -> RouterResult<()> {
let is_success_rate_routing_enabled =
dynamic_routing_algo_ref.is_success_rate_routing_enabled();
let is_elimination_enabled = dynamic_routing_algo_ref.is_elimination_enabled();
if is_success_rate_routing_enabled || is_elimination_enabled {
let payment_connector = &payment_attempt.connector.clone().ok_or(
errors::ApiErrorResponse::GenericNotFoundError {
message: "unable to derive payment connector from payment attempt".to_string(),
},
)?;
let routable_connector = routing_types::RoutableConnectorChoice {
choice_kind: api_models::routing::RoutableChoiceKind::FullStruct,
connector: euclid::enums::RoutableConnectors::from_str(payment_connector.as_str())
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("unable to infer routable_connector from connector")?,
merchant_connector_id: payment_attempt.merchant_connector_id.clone(),
};
logger::debug!(
"performing update-gateway-score for gateway with id {} in open_router for profile: {}",
routable_connector,
profile_id.get_string_repr()
);
routing::payments_routing::update_gateway_score_with_open_router(
state,
routable_connector.clone(),
profile_id,
&payment_attempt.merchant_id,
&payment_attempt.payment_id,
payment_attempt.status,
)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("failed to update gateway score in open_router service")?;
}
Ok(())
}
/// metrics for success based dynamic routing
#[cfg(all(feature = "v1", feature = "dynamic_routing"))]
#[instrument(skip_all)]
pub async fn push_metrics_with_update_window_for_success_based_routing(
state: &SessionState,
payment_attempt: &storage::PaymentAttempt,
routable_connectors: Vec<routing_types::RoutableConnectorChoice>,
profile_id: &id_type::ProfileId,
dynamic_routing_algo_ref: routing_types::DynamicRoutingAlgorithmRef,
dynamic_routing_config_params_interpolator: DynamicRoutingConfigParamsInterpolator,
) -> RouterResult<()> {
if let Some(success_based_algo_ref) = dynamic_routing_algo_ref.success_based_algorithm {
if success_based_algo_ref.enabled_feature != routing_types::DynamicRoutingFeatures::None {
let client = &state
.grpc_client
.dynamic_routing
.as_ref()
.ok_or(errors::ApiErrorResponse::GenericNotFoundError {
message: "dynamic routing gRPC client not found".to_string(),
})?
.success_rate_client;
let payment_connector = &payment_attempt.connector.clone().ok_or(
errors::ApiErrorResponse::GenericNotFoundError {
message: "unable to derive payment connector from payment attempt".to_string(),
},
)?;
let routable_connector = routing_types::RoutableConnectorChoice {
choice_kind: api_models::routing::RoutableChoiceKind::FullStruct,
connector: euclid::enums::RoutableConnectors::from_str(payment_connector.as_str())
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("unable to infer routable_connector from connector")?,
merchant_connector_id: payment_attempt.merchant_connector_id.clone(),
};
let payment_status_attribute =
get_desired_payment_status_for_dynamic_routing_metrics(payment_attempt.status);
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | true |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/routing/transformers.rs | crates/router/src/core/routing/transformers.rs | use api_models::routing::{
DynamicRoutingAlgorithm, MerchantRoutingAlgorithm, RoutingAlgorithmKind,
RoutingAlgorithmWrapper, RoutingDictionaryRecord,
};
#[cfg(feature = "v1")]
use api_models::{
open_router::{OpenRouterDecideGatewayRequest, PaymentInfo, RankingAlgorithm},
routing::RoutableConnectorChoice,
};
use common_utils::ext_traits::ValueExt;
use diesel_models::{
enums as storage_enums,
routing_algorithm::{RoutingAlgorithm, RoutingProfileMetadata},
};
#[cfg(feature = "v1")]
use hyperswitch_domain_models::payments::payment_attempt::PaymentAttempt;
use masking::{PeekInterface, Secret};
use crate::{
core::{errors, routing},
types::transformers::{ForeignFrom, ForeignInto, ForeignTryFrom},
};
impl ForeignFrom<RoutingProfileMetadata> for RoutingDictionaryRecord {
fn foreign_from(value: RoutingProfileMetadata) -> Self {
Self {
id: value.algorithm_id,
profile_id: value.profile_id,
name: value.name,
kind: value.kind.foreign_into(),
description: value.description.unwrap_or_default(),
created_at: value.created_at.assume_utc().unix_timestamp(),
modified_at: value.modified_at.assume_utc().unix_timestamp(),
algorithm_for: Some(value.algorithm_for),
decision_engine_routing_id: None,
}
}
}
impl ForeignFrom<RoutingAlgorithm> for RoutingDictionaryRecord {
fn foreign_from(value: RoutingAlgorithm) -> Self {
Self {
id: value.algorithm_id,
profile_id: value.profile_id,
name: value.name,
kind: value.kind.foreign_into(),
description: value.description.unwrap_or_default(),
created_at: value.created_at.assume_utc().unix_timestamp(),
modified_at: value.modified_at.assume_utc().unix_timestamp(),
algorithm_for: Some(value.algorithm_for),
decision_engine_routing_id: value.decision_engine_routing_id,
}
}
}
impl ForeignTryFrom<RoutingAlgorithm> for MerchantRoutingAlgorithm {
type Error = error_stack::Report<errors::ParsingError>;
fn foreign_try_from(value: RoutingAlgorithm) -> Result<Self, Self::Error> {
let algorithm: RoutingAlgorithmWrapper = match value.kind {
diesel_models::enums::RoutingAlgorithmKind::Dynamic => value
.algorithm_data
.parse_value::<DynamicRoutingAlgorithm>("RoutingAlgorithmDynamic")
.map(RoutingAlgorithmWrapper::Dynamic)?,
_ => value
.algorithm_data
.parse_value::<api_models::routing::StaticRoutingAlgorithm>("RoutingAlgorithm")
.map(RoutingAlgorithmWrapper::Static)?,
};
Ok(Self {
id: value.algorithm_id,
name: value.name,
profile_id: value.profile_id,
description: value.description.unwrap_or_default(),
algorithm,
created_at: value.created_at.assume_utc().unix_timestamp(),
modified_at: value.modified_at.assume_utc().unix_timestamp(),
algorithm_for: value.algorithm_for,
})
}
}
impl ForeignFrom<storage_enums::RoutingAlgorithmKind> for RoutingAlgorithmKind {
fn foreign_from(value: storage_enums::RoutingAlgorithmKind) -> Self {
match value {
storage_enums::RoutingAlgorithmKind::Single => Self::Single,
storage_enums::RoutingAlgorithmKind::Priority => Self::Priority,
storage_enums::RoutingAlgorithmKind::VolumeSplit => Self::VolumeSplit,
storage_enums::RoutingAlgorithmKind::Advanced => Self::Advanced,
storage_enums::RoutingAlgorithmKind::Dynamic => Self::Dynamic,
storage_enums::RoutingAlgorithmKind::ThreeDsDecisionRule => Self::ThreeDsDecisionRule,
}
}
}
impl ForeignFrom<RoutingAlgorithmKind> for storage_enums::RoutingAlgorithmKind {
fn foreign_from(value: RoutingAlgorithmKind) -> Self {
match value {
RoutingAlgorithmKind::Single => Self::Single,
RoutingAlgorithmKind::Priority => Self::Priority,
RoutingAlgorithmKind::VolumeSplit => Self::VolumeSplit,
RoutingAlgorithmKind::Advanced => Self::Advanced,
RoutingAlgorithmKind::Dynamic => Self::Dynamic,
RoutingAlgorithmKind::ThreeDsDecisionRule => Self::ThreeDsDecisionRule,
}
}
}
impl From<&routing::TransactionData<'_>> for storage_enums::TransactionType {
fn from(value: &routing::TransactionData<'_>) -> Self {
match value {
routing::TransactionData::Payment(_) => Self::Payment,
#[cfg(feature = "payouts")]
routing::TransactionData::Payout(_) => Self::Payout,
}
}
}
#[cfg(feature = "v1")]
pub trait OpenRouterDecideGatewayRequestExt {
fn construct_sr_request(
attempt: &PaymentAttempt,
eligible_gateway_list: Vec<RoutableConnectorChoice>,
ranking_algorithm: Option<RankingAlgorithm>,
is_elimination_enabled: bool,
) -> Self
where
Self: Sized;
fn construct_debit_request(
attempt: &PaymentAttempt,
metadata: Option<String>,
card_isin: Option<Secret<String>>,
ranking_algorithm: Option<RankingAlgorithm>,
) -> Self
where
Self: Sized;
}
#[cfg(feature = "v1")]
impl OpenRouterDecideGatewayRequestExt for OpenRouterDecideGatewayRequest {
fn construct_sr_request(
attempt: &PaymentAttempt,
eligible_gateway_list: Vec<RoutableConnectorChoice>,
ranking_algorithm: Option<RankingAlgorithm>,
is_elimination_enabled: bool,
) -> Self {
Self {
payment_info: PaymentInfo {
payment_id: attempt.payment_id.clone(),
amount: attempt.net_amount.get_order_amount(),
currency: attempt.currency.unwrap_or(storage_enums::Currency::USD),
payment_type: "ORDER_PAYMENT".to_string(),
payment_method_type: "UPI".into(), // TODO: once open-router makes this field string, we can send from attempt
payment_method: attempt.payment_method.unwrap_or_default(),
metadata: None,
card_isin: None,
},
merchant_id: attempt.profile_id.clone(),
eligible_gateway_list: Some(
eligible_gateway_list
.into_iter()
.map(|connector| connector.to_string())
.collect(),
),
ranking_algorithm,
elimination_enabled: Some(is_elimination_enabled),
}
}
fn construct_debit_request(
attempt: &PaymentAttempt,
metadata: Option<String>,
card_isin: Option<Secret<String>>,
ranking_algorithm: Option<RankingAlgorithm>,
) -> Self {
Self {
payment_info: PaymentInfo {
payment_id: attempt.payment_id.clone(),
amount: attempt.net_amount.get_total_amount(),
currency: attempt.currency.unwrap_or(storage_enums::Currency::USD),
payment_type: "ORDER_PAYMENT".to_string(),
card_isin: card_isin.map(|value| value.peek().clone()),
metadata,
payment_method_type: "UPI".into(), // TODO: once open-router makes this field string, we can send from attempt
payment_method: attempt.payment_method.unwrap_or_default(),
},
merchant_id: attempt.profile_id.clone(),
// eligible gateway list is not used in debit routing
eligible_gateway_list: None,
ranking_algorithm,
elimination_enabled: None,
}
}
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/proxy/utils.rs | crates/router/src/core/proxy/utils.rs | use api_models::{payment_methods::PaymentMethodId, proxy as proxy_api_models};
use common_utils::{
crypto::{DecodeMessage, GcmAes256},
encryption::Encryption,
ext_traits::{BytesExt, Encode, OptionExt},
id_type,
};
use error_stack::ResultExt;
use hyperswitch_domain_models::{behaviour::Conversion, payment_methods};
use masking::{Mask, PeekInterface};
use serde_json::Value;
use x509_parser::nom::{
bytes::complete::{tag, take_while1},
character::complete::{char, multispace0},
sequence::{delimited, preceded, terminated},
IResult,
};
use crate::{
core::{
errors::{self, RouterResult},
payment_methods::{cards, vault},
},
routes::SessionState,
types::{domain, payment_methods as pm_types},
};
pub struct ProxyRequestWrapper(pub proxy_api_models::ProxyRequest);
pub enum ProxyRecord {
PaymentMethodRecord(Box<domain::PaymentMethod>),
VolatilePaymentMethodRecord(Box<domain::PaymentMethod>),
TokenizationRecord(Box<domain::Tokenization>),
}
impl ProxyRequestWrapper {
pub async fn get_proxy_record(
&self,
state: &SessionState,
key_store: &domain::MerchantKeyStore,
storage_scheme: common_enums::enums::MerchantStorageScheme,
) -> RouterResult<ProxyRecord> {
let token = &self.0.token;
match self.0.token_type {
proxy_api_models::TokenType::PaymentMethodId => {
let pm_id = PaymentMethodId {
payment_method_id: token.clone(),
};
let pm_id =
id_type::GlobalPaymentMethodId::generate_from_string(pm_id.payment_method_id)
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Unable to generate GlobalPaymentMethodId")?;
let payment_method_record = state
.store
.find_payment_method(key_store, &pm_id, storage_scheme)
.await
.change_context(errors::ApiErrorResponse::PaymentMethodNotFound)?;
Ok(ProxyRecord::PaymentMethodRecord(Box::new(
payment_method_record,
)))
}
proxy_api_models::TokenType::TokenizationId => {
let token_id = id_type::GlobalTokenId::from_string(token.clone().as_str())
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable(
"Error while coneverting from string to GlobalTokenId type",
)?;
let db = state.store.as_ref();
let tokenization_record = db
.get_entity_id_vault_id_by_token_id(&token_id, key_store)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Error while fetching tokenization record from vault")?;
Ok(ProxyRecord::TokenizationRecord(Box::new(
tokenization_record,
)))
}
proxy_api_models::TokenType::VolatilePaymentMethodId => {
let pm_id = token.as_str();
let encryption_key = key_store.key.get_inner();
let redis_conn = state
.store
.get_redis_conn()
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed to get redis connection")?;
let response = redis_conn.get_key::<bytes::Bytes>(&pm_id.into()).await;
let payment_method_record = match response {
Ok(resp) => {
let payment_method = resp
.parse_struct::<diesel_models::PaymentMethod>("PaymentMethod")
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Error getting PaymentMethod from redis")?;
let keymanager_state = &state.into();
let domain_payment_method = domain::PaymentMethod::convert_back(
keymanager_state,
payment_method,
key_store.key.get_inner(),
key_store.merchant_id.clone().into(),
)
.await
.change_context(errors::StorageError::EncryptionError)
.change_context(errors::ApiErrorResponse::InternalServerError)?;
Ok(domain_payment_method)
}
Err(err) => {
Err(err).change_context(errors::ApiErrorResponse::UnprocessableEntity {
message: "Token is invalid or expired".into(),
})
}
}?;
Ok(ProxyRecord::VolatilePaymentMethodRecord(Box::new(
payment_method_record,
)))
}
}
}
pub fn get_headers(&self) -> Vec<(String, masking::Maskable<String>)> {
self.0
.headers
.as_map()
.iter()
.map(|(key, value)| (key.clone(), value.clone().into_masked()))
.collect()
}
pub fn get_destination_url(&self) -> &str {
self.0.destination_url.as_str()
}
pub fn get_method(&self) -> common_utils::request::Method {
self.0.method
}
}
impl ProxyRecord {
fn get_vault_id(&self) -> RouterResult<payment_methods::VaultId> {
match self {
Self::PaymentMethodRecord(payment_method) => payment_method
.locker_id
.clone()
.get_required_value("vault_id")
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Locker id not present in Payment Method Entry"),
Self::TokenizationRecord(tokenization_record) => Ok(
payment_methods::VaultId::generate(tokenization_record.locker_id.clone()),
),
Self::VolatilePaymentMethodRecord(payment_method) => payment_method
.locker_id
.clone()
.get_required_value("vault_id")
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Locker id not present in Volatile Payment Method Entry"),
}
}
fn get_customer_id(&self) -> RouterResult<Option<id_type::GlobalCustomerId>> {
match self {
Self::PaymentMethodRecord(payment_method) => {
let customer_id = payment_method
.customer_id
.clone()
.get_required_value("customer_id")
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Customer id not present in Payment Method Entry")?;
Ok(Some(customer_id))
}
Self::TokenizationRecord(tokenization_record) => {
Ok(Some(tokenization_record.customer_id.clone()))
}
Self::VolatilePaymentMethodRecord(payment_method) => {
Ok(payment_method.customer_id.clone())
}
}
}
pub async fn get_vault_data(
&self,
state: &SessionState,
platform: domain::Platform,
) -> RouterResult<Value> {
match self {
Self::PaymentMethodRecord(_) => {
let customer_id = self
.get_customer_id()?
.get_required_value("customer_id")
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Locker id not present in Payment Method Entry")?;
let vault_resp = vault::retrieve_payment_method_from_vault_internal(
state,
&platform,
&self.get_vault_id()?,
&customer_id,
)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Error while fetching data from vault")?;
Ok(vault_resp
.data
.encode_to_value()
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed to serialize vault data")?)
}
Self::TokenizationRecord(_) => {
let customer_id = self
.get_customer_id()?
.get_required_value("customer_id")
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Locker id not present in Tokenization Record")?;
let vault_request = pm_types::VaultRetrieveRequest {
entity_id: customer_id,
vault_id: self.get_vault_id()?,
};
let vault_data = vault::retrieve_value_from_vault(state, vault_request)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed to retrieve vault data")?;
Ok(vault_data.get("data").cloned().unwrap_or(Value::Null))
}
Self::VolatilePaymentMethodRecord(_) => {
//retrieve from redis
let vault_id = self.get_vault_id()?;
let key_store = platform.get_provider().get_key_store();
let encryption_key = key_store.key.get_inner();
let redis_conn = state
.store
.get_redis_conn()
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed to get redis connection")?;
let response = redis_conn
.get_and_deserialize_key::<Encryption>(
&vault_id.get_string_repr().into(),
"Vec<u8>",
)
.await;
match response {
Ok(resp) => {
let decrypted_payload: domain::PaymentMethodVaultingData = cards::decrypt_generic_data(state, Some(resp), key_store)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed to decrypt volatile payment method vault data")?.get_required_value("PaymentMethodVaultingData")
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed to get required decrypted volatile payment method vault data")?;
Ok(decrypted_payload
.encode_to_value()
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed to serialize vault data")?)
}
Err(err) => {
Err(err).change_context(errors::ApiErrorResponse::UnprocessableEntity {
message: "Token is invalid or expired".into(),
})
}
}
}
}
}
}
#[derive(Debug)]
pub struct TokenReference {
pub field: String,
}
pub fn parse_token(input: &str) -> IResult<&str, TokenReference> {
let (input, field) = delimited(
tag("{{"),
preceded(
multispace0,
preceded(
char('$'),
terminated(
take_while1(|c: char| c.is_alphanumeric() || c == '_'),
multispace0,
),
),
),
tag("}}"),
)(input)?;
Ok((
input,
TokenReference {
field: field.to_string(),
},
))
}
pub fn contains_token(s: &str) -> bool {
s.contains("{{") && s.contains("$") && s.contains("}}")
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/payment_link/validator.rs | crates/router/src/core/payment_link/validator.rs | use actix_http::header;
use api_models::admin::PaymentLinkConfig;
use common_utils::validation::validate_domain_against_allowed_domains;
use error_stack::{report, ResultExt};
use url::Url;
use crate::{
core::errors::{self, RouterResult},
types::storage::PaymentLink,
};
pub fn validate_secure_payment_link_render_request(
request_headers: &header::HeaderMap,
payment_link: &PaymentLink,
payment_link_config: &PaymentLinkConfig,
) -> RouterResult<()> {
let link_id = payment_link.payment_link_id.clone();
let allowed_domains = payment_link_config
.allowed_domains
.clone()
.ok_or(report!(errors::ApiErrorResponse::InvalidRequestUrl))
.attach_printable_lazy(|| {
format!("Secure payment link was not generated for {link_id}\nmissing allowed_domains")
})?;
// Validate secure_link was generated
if payment_link.secure_link.clone().is_none() {
return Err(report!(errors::ApiErrorResponse::InvalidRequestUrl)).attach_printable_lazy(
|| format!("Secure payment link was not generated for {link_id}\nmissing secure_link"),
);
}
// Fetch destination is "iframe"
match request_headers.get("sec-fetch-dest").and_then(|v| v.to_str().ok()) {
Some("iframe") => Ok(()),
Some(requestor) => Err(report!(errors::ApiErrorResponse::AccessForbidden {
resource: "payment_link".to_string(),
}))
.attach_printable_lazy(|| {
format!(
"Access to payment_link [{link_id}] is forbidden when requested through {requestor}",
)
}),
None => Err(report!(errors::ApiErrorResponse::AccessForbidden {
resource: "payment_link".to_string(),
}))
.attach_printable_lazy(|| {
format!(
"Access to payment_link [{link_id}] is forbidden when sec-fetch-dest is not present in request headers",
)
}),
}?;
// Validate origin / referer
let domain_in_req = {
let origin_or_referer = request_headers
.get("origin")
.or_else(|| request_headers.get("referer"))
.and_then(|v| v.to_str().ok())
.ok_or_else(|| {
report!(errors::ApiErrorResponse::AccessForbidden {
resource: "payment_link".to_string(),
})
})
.attach_printable_lazy(|| {
format!(
"Access to payment_link [{link_id}] is forbidden when origin or referer is not present in request headers",
)
})?;
let url = Url::parse(origin_or_referer)
.map_err(|_| {
report!(errors::ApiErrorResponse::AccessForbidden {
resource: "payment_link".to_string(),
})
})
.attach_printable_lazy(|| {
format!("Invalid URL found in request headers {origin_or_referer}")
})?;
url.host_str()
.and_then(|host| url.port().map(|port| format!("{host}:{port}")))
.or_else(|| url.host_str().map(String::from))
.ok_or_else(|| {
report!(errors::ApiErrorResponse::AccessForbidden {
resource: "payment_link".to_string(),
})
})
.attach_printable_lazy(|| {
format!("host or port not found in request headers {url:?}")
})?
};
if validate_domain_against_allowed_domains(&domain_in_req, allowed_domains) {
Ok(())
} else {
Err(report!(errors::ApiErrorResponse::AccessForbidden {
resource: "payment_link".to_string(),
}))
.attach_printable_lazy(|| {
format!(
"Access to payment_link [{link_id}] is forbidden from requestor - {domain_in_req}",
)
})
}
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/user/theme.rs | crates/router/src/core/user/theme.rs | use api_models::user::theme as theme_api;
use common_enums::EntityType;
use common_utils::{
ext_traits::{ByteSliceExt, Encode},
types::user::ThemeLineage,
};
use diesel_models::user::theme::{ThemeNew, ThemeUpdate};
use error_stack::ResultExt;
use hyperswitch_domain_models::api::ApplicationResponse;
use masking::ExposeInterface;
use rdkafka::message::ToBytes;
use uuid::Uuid;
use crate::{
core::errors::{StorageErrorExt, UserErrors, UserResponse},
routes::SessionState,
services::authentication::UserFromToken,
utils::user::theme as theme_utils,
};
// TODO: To be deprecated
pub async fn get_theme_using_lineage(
state: SessionState,
lineage: ThemeLineage,
) -> UserResponse<theme_api::GetThemeResponse> {
let theme = state
.store
.find_theme_by_lineage(lineage)
.await
.to_not_found_response(UserErrors::ThemeNotFound)?;
let file = theme_utils::retrieve_file_from_theme_bucket(
&state,
&theme_utils::get_theme_file_key(&theme.theme_id),
)
.await?;
let parsed_data = file
.to_bytes()
.parse_struct("ThemeData")
.change_context(UserErrors::InternalServerError)?;
Ok(ApplicationResponse::Json(theme_api::GetThemeResponse {
email_config: theme.email_config(),
theme_id: theme.theme_id,
theme_name: theme.theme_name,
entity_type: theme.entity_type,
tenant_id: theme.tenant_id,
org_id: theme.org_id,
merchant_id: theme.merchant_id,
profile_id: theme.profile_id,
theme_data: parsed_data,
}))
}
// TODO: To be deprecated
pub async fn get_theme_using_theme_id(
state: SessionState,
theme_id: String,
) -> UserResponse<theme_api::GetThemeResponse> {
let theme = state
.store
.find_theme_by_theme_id(theme_id.clone())
.await
.to_not_found_response(UserErrors::ThemeNotFound)?;
let file = theme_utils::retrieve_file_from_theme_bucket(
&state,
&theme_utils::get_theme_file_key(&theme_id),
)
.await?;
let parsed_data = file
.to_bytes()
.parse_struct("ThemeData")
.change_context(UserErrors::InternalServerError)?;
Ok(ApplicationResponse::Json(theme_api::GetThemeResponse {
email_config: theme.email_config(),
theme_id: theme.theme_id,
theme_name: theme.theme_name,
entity_type: theme.entity_type,
tenant_id: theme.tenant_id,
org_id: theme.org_id,
merchant_id: theme.merchant_id,
profile_id: theme.profile_id,
theme_data: parsed_data,
}))
}
// TODO: To be deprecated
pub async fn upload_file_to_theme_storage(
state: SessionState,
theme_id: String,
request: theme_api::UploadFileRequest,
) -> UserResponse<()> {
let db_theme = state
.store
.find_theme_by_theme_id(theme_id)
.await
.to_not_found_response(UserErrors::ThemeNotFound)?;
theme_utils::upload_file_to_theme_bucket(
&state,
&theme_utils::get_specific_file_key(&db_theme.theme_id, &request.asset_name),
request.asset_data.expose(),
)
.await?;
Ok(ApplicationResponse::StatusOk)
}
// TODO: To be deprecated
pub async fn create_theme(
state: SessionState,
request: theme_api::CreateThemeRequest,
) -> UserResponse<theme_api::GetThemeResponse> {
theme_utils::validate_lineage(&state, &request.lineage).await?;
let email_config = if cfg!(feature = "email") {
request.email_config.ok_or(UserErrors::MissingEmailConfig)?
} else {
request
.email_config
.unwrap_or(state.conf.theme.email_config.clone())
};
let new_theme = ThemeNew::new(
Uuid::new_v4().to_string(),
request.theme_name,
request.lineage,
email_config,
);
let db_theme = state
.store
.insert_theme(new_theme)
.await
.to_duplicate_response(UserErrors::ThemeAlreadyExists)?;
theme_utils::upload_file_to_theme_bucket(
&state,
&theme_utils::get_theme_file_key(&db_theme.theme_id),
request
.theme_data
.encode_to_vec()
.change_context(UserErrors::InternalServerError)?,
)
.await?;
let file = theme_utils::retrieve_file_from_theme_bucket(
&state,
&theme_utils::get_theme_file_key(&db_theme.theme_id),
)
.await?;
let parsed_data = file
.to_bytes()
.parse_struct("ThemeData")
.change_context(UserErrors::InternalServerError)?;
Ok(ApplicationResponse::Json(theme_api::GetThemeResponse {
email_config: db_theme.email_config(),
theme_id: db_theme.theme_id,
entity_type: db_theme.entity_type,
tenant_id: db_theme.tenant_id,
org_id: db_theme.org_id,
merchant_id: db_theme.merchant_id,
profile_id: db_theme.profile_id,
theme_name: db_theme.theme_name,
theme_data: parsed_data,
}))
}
// TODO: To be deprecated
pub async fn update_theme(
state: SessionState,
theme_id: String,
request: theme_api::UpdateThemeRequest,
) -> UserResponse<theme_api::GetThemeResponse> {
let db_theme = match request.email_config {
Some(email_config) => {
let theme_update = ThemeUpdate::EmailConfig { email_config };
state
.store
.update_theme_by_theme_id(theme_id.clone(), theme_update)
.await
.to_not_found_response(UserErrors::ThemeNotFound)?
}
None => state
.store
.find_theme_by_theme_id(theme_id)
.await
.to_not_found_response(UserErrors::ThemeNotFound)?,
};
if let Some(theme_data) = request.theme_data {
theme_utils::upload_file_to_theme_bucket(
&state,
&theme_utils::get_theme_file_key(&db_theme.theme_id),
theme_data
.encode_to_vec()
.change_context(UserErrors::InternalServerError)
.attach_printable("Failed to parse ThemeData")?,
)
.await?;
}
let file = theme_utils::retrieve_file_from_theme_bucket(
&state,
&theme_utils::get_theme_file_key(&db_theme.theme_id),
)
.await?;
let parsed_data = file
.to_bytes()
.parse_struct("ThemeData")
.change_context(UserErrors::InternalServerError)?;
Ok(ApplicationResponse::Json(theme_api::GetThemeResponse {
email_config: db_theme.email_config(),
theme_id: db_theme.theme_id,
entity_type: db_theme.entity_type,
tenant_id: db_theme.tenant_id,
org_id: db_theme.org_id,
merchant_id: db_theme.merchant_id,
profile_id: db_theme.profile_id,
theme_name: db_theme.theme_name,
theme_data: parsed_data,
}))
}
// TODO: To be deprecated
pub async fn delete_theme(state: SessionState, theme_id: String) -> UserResponse<()> {
state
.store
.delete_theme_by_theme_id(theme_id.clone())
.await
.to_not_found_response(UserErrors::ThemeNotFound)?;
// TODO (#6717): Delete theme folder from the theme storage.
// Currently there is no simple or easy way to delete a whole folder from S3.
// So, we are not deleting the theme folder from the theme storage.
Ok(ApplicationResponse::StatusOk)
}
pub async fn create_user_theme(
state: SessionState,
user_from_token: UserFromToken,
request: theme_api::CreateUserThemeRequest,
) -> UserResponse<theme_api::GetThemeResponse> {
let email_config = if cfg!(feature = "email") {
request.email_config.ok_or(UserErrors::MissingEmailConfig)?
} else {
request
.email_config
.unwrap_or(state.conf.theme.email_config.clone())
};
let lineage = theme_utils::get_theme_lineage_from_user_token(
&user_from_token,
&state,
&request.entity_type,
)
.await?;
let new_theme = ThemeNew::new(
Uuid::new_v4().to_string(),
request.theme_name,
lineage,
email_config,
);
let db_theme = state
.store
.insert_theme(new_theme)
.await
.to_duplicate_response(UserErrors::ThemeAlreadyExists)?;
theme_utils::upload_file_to_theme_bucket(
&state,
&theme_utils::get_theme_file_key(&db_theme.theme_id),
request
.theme_data
.encode_to_vec()
.change_context(UserErrors::InternalServerError)?,
)
.await?;
let file = theme_utils::retrieve_file_from_theme_bucket(
&state,
&theme_utils::get_theme_file_key(&db_theme.theme_id),
)
.await?;
let parsed_data = file
.to_bytes()
.parse_struct("ThemeData")
.change_context(UserErrors::InternalServerError)?;
Ok(ApplicationResponse::Json(theme_api::GetThemeResponse {
email_config: db_theme.email_config(),
theme_id: db_theme.theme_id,
entity_type: db_theme.entity_type,
tenant_id: db_theme.tenant_id,
org_id: db_theme.org_id,
merchant_id: db_theme.merchant_id,
profile_id: db_theme.profile_id,
theme_name: db_theme.theme_name,
theme_data: parsed_data,
}))
}
pub async fn delete_user_theme(
state: SessionState,
user_from_token: UserFromToken,
theme_id: String,
) -> UserResponse<()> {
let db_theme = state
.store
.find_theme_by_theme_id(theme_id.clone())
.await
.to_not_found_response(UserErrors::ThemeNotFound)?;
let user_role_info = user_from_token
.get_role_info_from_db(&state)
.await
.attach_printable("Invalid role_id in JWT")?;
let user_entity_type = user_role_info.get_entity_type();
theme_utils::can_user_access_theme(&user_from_token, &user_entity_type, &db_theme).await?;
state
.store
.delete_theme_by_theme_id(theme_id.clone())
.await
.to_not_found_response(UserErrors::ThemeNotFound)?;
// TODO (#6717): Delete theme folder from the theme storage.
// Currently there is no simple or easy way to delete a whole folder from S3.
// So, we are not deleting the theme folder from the theme storage.
Ok(ApplicationResponse::StatusOk)
}
pub async fn update_user_theme(
state: SessionState,
theme_id: String,
user_from_token: UserFromToken,
request: theme_api::UpdateThemeRequest,
) -> UserResponse<theme_api::GetThemeResponse> {
let db_theme = state
.store
.find_theme_by_theme_id(theme_id.clone())
.await
.to_not_found_response(UserErrors::ThemeNotFound)?;
let user_role_info = user_from_token
.get_role_info_from_db(&state)
.await
.attach_printable("Invalid role_id in JWT")?;
let user_entity_type = user_role_info.get_entity_type();
theme_utils::can_user_access_theme(&user_from_token, &user_entity_type, &db_theme).await?;
let db_theme = match request.email_config {
Some(email_config) => {
let theme_update = ThemeUpdate::EmailConfig { email_config };
state
.store
.update_theme_by_theme_id(theme_id.clone(), theme_update)
.await
.change_context(UserErrors::InternalServerError)?
}
None => db_theme,
};
if let Some(theme_data) = request.theme_data {
theme_utils::upload_file_to_theme_bucket(
&state,
&theme_utils::get_theme_file_key(&db_theme.theme_id),
theme_data
.encode_to_vec()
.change_context(UserErrors::InternalServerError)
.attach_printable("Failed to parse ThemeData")?,
)
.await?;
}
let file = theme_utils::retrieve_file_from_theme_bucket(
&state,
&theme_utils::get_theme_file_key(&db_theme.theme_id),
)
.await?;
let parsed_data = file
.to_bytes()
.parse_struct("ThemeData")
.change_context(UserErrors::InternalServerError)?;
Ok(ApplicationResponse::Json(theme_api::GetThemeResponse {
email_config: db_theme.email_config(),
theme_id: db_theme.theme_id,
entity_type: db_theme.entity_type,
tenant_id: db_theme.tenant_id,
org_id: db_theme.org_id,
merchant_id: db_theme.merchant_id,
profile_id: db_theme.profile_id,
theme_name: db_theme.theme_name,
theme_data: parsed_data,
}))
}
pub async fn upload_file_to_user_theme_storage(
state: SessionState,
theme_id: String,
user_from_token: UserFromToken,
request: theme_api::UploadFileRequest,
) -> UserResponse<()> {
let db_theme = state
.store
.find_theme_by_theme_id(theme_id)
.await
.to_not_found_response(UserErrors::ThemeNotFound)?;
let user_role_info = user_from_token
.get_role_info_from_db(&state)
.await
.attach_printable("Invalid role_id in JWT")?;
let user_entity_type = user_role_info.get_entity_type();
theme_utils::can_user_access_theme(&user_from_token, &user_entity_type, &db_theme).await?;
theme_utils::upload_file_to_theme_bucket(
&state,
&theme_utils::get_specific_file_key(&db_theme.theme_id, &request.asset_name),
request.asset_data.expose(),
)
.await?;
Ok(ApplicationResponse::StatusOk)
}
pub async fn list_all_themes_in_lineage(
state: SessionState,
user: UserFromToken,
entity_type: EntityType,
) -> UserResponse<Vec<theme_api::GetThemeResponse>> {
let lineage =
theme_utils::get_theme_lineage_from_user_token(&user, &state, &entity_type).await?;
let db_themes = state
.store
.list_themes_at_and_under_lineage(lineage)
.await
.change_context(UserErrors::InternalServerError)?;
let mut themes = Vec::new();
for theme in db_themes {
match theme_utils::retrieve_file_from_theme_bucket(
&state,
&theme_utils::get_theme_file_key(&theme.theme_id),
)
.await
{
Ok(file) => {
match file
.to_bytes()
.parse_struct("ThemeData")
.change_context(UserErrors::InternalServerError)
{
Ok(parsed_data) => {
themes.push(theme_api::GetThemeResponse {
email_config: theme.email_config(),
theme_id: theme.theme_id,
theme_name: theme.theme_name,
entity_type: theme.entity_type,
tenant_id: theme.tenant_id,
org_id: theme.org_id,
merchant_id: theme.merchant_id,
profile_id: theme.profile_id,
theme_data: parsed_data,
});
}
Err(_) => {
return Err(UserErrors::ErrorRetrievingFile.into());
}
}
}
Err(_) => {
return Err(UserErrors::ErrorRetrievingFile.into());
}
}
}
Ok(ApplicationResponse::Json(themes))
}
pub async fn get_user_theme_using_theme_id(
state: SessionState,
user_from_token: UserFromToken,
theme_id: String,
) -> UserResponse<theme_api::GetThemeResponse> {
let db_theme = state
.store
.find_theme_by_theme_id(theme_id.clone())
.await
.to_not_found_response(UserErrors::ThemeNotFound)?;
let user_role_info = user_from_token
.get_role_info_from_db(&state)
.await
.attach_printable("Invalid role_id in JWT")?;
let user_role_entity = user_role_info.get_entity_type();
theme_utils::can_user_access_theme(&user_from_token, &user_role_entity, &db_theme).await?;
let file = theme_utils::retrieve_file_from_theme_bucket(
&state,
&theme_utils::get_theme_file_key(&theme_id),
)
.await?;
let parsed_data = file
.to_bytes()
.parse_struct("ThemeData")
.change_context(UserErrors::InternalServerError)?;
Ok(ApplicationResponse::Json(theme_api::GetThemeResponse {
email_config: db_theme.email_config(),
theme_id: db_theme.theme_id,
theme_name: db_theme.theme_name,
entity_type: db_theme.entity_type,
tenant_id: db_theme.tenant_id,
org_id: db_theme.org_id,
merchant_id: db_theme.merchant_id,
profile_id: db_theme.profile_id,
theme_data: parsed_data,
}))
}
pub async fn get_user_theme_using_lineage(
state: SessionState,
user_from_token: UserFromToken,
entity_type: EntityType,
) -> UserResponse<theme_api::GetThemeResponse> {
let lineage =
theme_utils::get_theme_lineage_from_user_token(&user_from_token, &state, &entity_type)
.await?;
let theme = state
.store
.find_theme_by_lineage(lineage)
.await
.to_not_found_response(UserErrors::ThemeNotFound)?;
let file = theme_utils::retrieve_file_from_theme_bucket(
&state,
&theme_utils::get_theme_file_key(&theme.theme_id),
)
.await?;
let parsed_data = file
.to_bytes()
.parse_struct("ThemeData")
.change_context(UserErrors::InternalServerError)?;
Ok(ApplicationResponse::Json(theme_api::GetThemeResponse {
email_config: theme.email_config(),
theme_id: theme.theme_id,
theme_name: theme.theme_name,
entity_type: theme.entity_type,
tenant_id: theme.tenant_id,
org_id: theme.org_id,
merchant_id: theme.merchant_id,
profile_id: theme.profile_id,
theme_data: parsed_data,
}))
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/user/sample_data.rs | crates/router/src/core/user/sample_data.rs | use api_models::user::sample_data::SampleDataRequest;
use common_utils::errors::ReportSwitchExt;
use diesel_models::{DisputeNew, RefundNew};
use error_stack::ResultExt;
use hyperswitch_domain_models::payments::PaymentIntent;
pub type SampleDataApiResponse<T> = SampleDataResult<ApplicationResponse<T>>;
use crate::{
core::errors::sample_data::{SampleDataError, SampleDataResult},
routes::{app::ReqState, SessionState},
services::{authentication::UserFromToken, ApplicationResponse},
utils,
};
#[cfg(feature = "v1")]
pub async fn generate_sample_data_for_user(
state: SessionState,
user_from_token: UserFromToken,
req: SampleDataRequest,
_req_state: ReqState,
) -> SampleDataApiResponse<()> {
let sample_data = utils::user::sample_data::generate_sample_data(
&state,
req,
&user_from_token.merchant_id,
&user_from_token.org_id,
)
.await?;
let key_store = state
.store
.get_merchant_key_store_by_merchant_id(
&user_from_token.merchant_id,
&state.store.get_master_key().to_vec().into(),
)
.await
.change_context(SampleDataError::InternalServerError)
.attach_printable("Not able to fetch merchant key store")?; // If not able to fetch merchant key store for any reason, this should be an internal server error
let (payment_intents, payment_attempts, refunds, disputes): (
Vec<PaymentIntent>,
Vec<diesel_models::user::sample_data::PaymentAttemptBatchNew>,
Vec<RefundNew>,
Vec<DisputeNew>,
) = sample_data.into_iter().fold(
(Vec::new(), Vec::new(), Vec::new(), Vec::new()),
|(mut pi, mut pa, mut rf, mut dp), (payment_intent, payment_attempt, refund, dispute)| {
pi.push(payment_intent);
pa.push(payment_attempt);
if let Some(refund) = refund {
rf.push(refund);
}
if let Some(dispute) = dispute {
dp.push(dispute);
}
(pi, pa, rf, dp)
},
);
let key_manager_state = &(&state).into();
state
.store
.insert_payment_intents_batch_for_sample_data(&(&state).into(), payment_intents, &key_store)
.await
.switch()?;
state
.store
.insert_payment_attempts_batch_for_sample_data(
payment_attempts,
key_manager_state,
&key_store,
)
.await
.switch()?;
state
.store
.insert_refunds_batch_for_sample_data(refunds)
.await
.switch()?;
state
.store
.insert_disputes_batch_for_sample_data(disputes)
.await
.switch()?;
Ok(ApplicationResponse::StatusOk)
}
#[cfg(feature = "v1")]
pub async fn delete_sample_data_for_user(
state: SessionState,
user_from_token: UserFromToken,
_req: SampleDataRequest,
_req_state: ReqState,
) -> SampleDataApiResponse<()> {
let merchant_id_del = user_from_token.merchant_id;
let key_manager_state = &(&state).into();
let key_store = state
.store
.get_merchant_key_store_by_merchant_id(
&merchant_id_del,
&state.store.get_master_key().to_vec().into(),
)
.await
.change_context(SampleDataError::InternalServerError)
.attach_printable("Not able to fetch merchant key store")?; // If not able to fetch merchant key store for any reason, this should be an internal server error
state
.store
.delete_payment_intents_for_sample_data(key_manager_state, &merchant_id_del, &key_store)
.await
.switch()?;
state
.store
.delete_payment_attempts_for_sample_data(&merchant_id_del, key_manager_state, &key_store)
.await
.switch()?;
state
.store
.delete_refunds_for_sample_data(&merchant_id_del)
.await
.switch()?;
state
.store
.delete_disputes_for_sample_data(&merchant_id_del)
.await
.switch()?;
Ok(ApplicationResponse::StatusOk)
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/user/dashboard_metadata.rs | crates/router/src/core/user/dashboard_metadata.rs | use api_models::user::dashboard_metadata::{self as api, GetMultipleMetaDataPayload};
#[cfg(feature = "email")]
use common_enums::EntityType;
use diesel_models::{
enums::DashboardMetadata as DBEnum, user::dashboard_metadata::DashboardMetadata,
};
use error_stack::{report, ResultExt};
use hyperswitch_interfaces::crm::CrmPayload;
#[cfg(feature = "email")]
use masking::ExposeInterface;
use masking::{PeekInterface, Secret};
use router_env::logger;
use crate::{
core::errors::{UserErrors, UserResponse, UserResult},
routes::{app::ReqState, SessionState},
services::{authentication::UserFromToken, ApplicationResponse},
types::domain::{self, user::dashboard_metadata as types, MerchantKeyStore},
utils::user::{self as user_utils, dashboard_metadata as utils},
};
#[cfg(feature = "email")]
use crate::{services::email::types as email_types, utils::user::theme as theme_utils};
pub async fn set_metadata(
state: SessionState,
user: UserFromToken,
request: api::SetMetaDataRequest,
_req_state: ReqState,
) -> UserResponse<()> {
let metadata_value = parse_set_request(request)?;
let metadata_key = DBEnum::from(&metadata_value);
insert_metadata(&state, user, metadata_key, metadata_value).await?;
Ok(ApplicationResponse::StatusOk)
}
pub async fn get_multiple_metadata(
state: SessionState,
user: UserFromToken,
request: GetMultipleMetaDataPayload,
_req_state: ReqState,
) -> UserResponse<Vec<api::GetMetaDataResponse>> {
let metadata_keys: Vec<DBEnum> = request.results.into_iter().map(parse_get_request).collect();
let metadata = fetch_metadata(&state, &user, metadata_keys.clone()).await?;
let mut response = Vec::with_capacity(metadata_keys.len());
for key in metadata_keys {
let data = metadata.iter().find(|ele| ele.data_key == key);
let resp;
if data.is_none() && utils::is_backfill_required(key) {
let backfill_data = backfill_metadata(&state, &user, &key).await?;
resp = into_response(backfill_data.as_ref(), key)?;
} else {
resp = into_response(data, key)?;
}
response.push(resp);
}
Ok(ApplicationResponse::Json(response))
}
fn parse_set_request(data_enum: api::SetMetaDataRequest) -> UserResult<types::MetaData> {
match data_enum {
api::SetMetaDataRequest::ProductionAgreement(req) => {
let ip_address = req
.ip_address
.ok_or(report!(UserErrors::InternalServerError))
.attach_printable("Error Getting Ip Address")?;
Ok(types::MetaData::ProductionAgreement(
types::ProductionAgreementValue {
version: req.version,
ip_address,
timestamp: common_utils::date_time::now(),
},
))
}
api::SetMetaDataRequest::SetupProcessor(req) => Ok(types::MetaData::SetupProcessor(req)),
api::SetMetaDataRequest::ConfigureEndpoint => Ok(types::MetaData::ConfigureEndpoint(true)),
api::SetMetaDataRequest::SetupComplete => Ok(types::MetaData::SetupComplete(true)),
api::SetMetaDataRequest::FirstProcessorConnected(req) => {
Ok(types::MetaData::FirstProcessorConnected(req))
}
api::SetMetaDataRequest::SecondProcessorConnected(req) => {
Ok(types::MetaData::SecondProcessorConnected(req))
}
api::SetMetaDataRequest::ConfiguredRouting(req) => {
Ok(types::MetaData::ConfiguredRouting(req))
}
api::SetMetaDataRequest::TestPayment(req) => Ok(types::MetaData::TestPayment(req)),
api::SetMetaDataRequest::IntegrationMethod(req) => {
Ok(types::MetaData::IntegrationMethod(req))
}
api::SetMetaDataRequest::ConfigurationType(req) => {
Ok(types::MetaData::ConfigurationType(req))
}
api::SetMetaDataRequest::IntegrationCompleted => {
Ok(types::MetaData::IntegrationCompleted(true))
}
api::SetMetaDataRequest::SPRoutingConfigured(req) => {
Ok(types::MetaData::SPRoutingConfigured(req))
}
api::SetMetaDataRequest::Feedback(req) => Ok(types::MetaData::Feedback(req)),
api::SetMetaDataRequest::ProdIntent(req) => Ok(types::MetaData::ProdIntent(req)),
api::SetMetaDataRequest::SPTestPayment => Ok(types::MetaData::SPTestPayment(true)),
api::SetMetaDataRequest::DownloadWoocom => Ok(types::MetaData::DownloadWoocom(true)),
api::SetMetaDataRequest::ConfigureWoocom => Ok(types::MetaData::ConfigureWoocom(true)),
api::SetMetaDataRequest::SetupWoocomWebhook => {
Ok(types::MetaData::SetupWoocomWebhook(true))
}
api::SetMetaDataRequest::IsMultipleConfiguration => {
Ok(types::MetaData::IsMultipleConfiguration(true))
}
api::SetMetaDataRequest::IsChangePasswordRequired => {
Ok(types::MetaData::IsChangePasswordRequired(true))
}
api::SetMetaDataRequest::OnboardingSurvey(req) => {
Ok(types::MetaData::OnboardingSurvey(req))
}
api::SetMetaDataRequest::ReconStatus(req) => Ok(types::MetaData::ReconStatus(req)),
}
}
fn parse_get_request(data_enum: api::GetMetaDataRequest) -> DBEnum {
match data_enum {
api::GetMetaDataRequest::ProductionAgreement => DBEnum::ProductionAgreement,
api::GetMetaDataRequest::SetupProcessor => DBEnum::SetupProcessor,
api::GetMetaDataRequest::ConfigureEndpoint => DBEnum::ConfigureEndpoint,
api::GetMetaDataRequest::SetupComplete => DBEnum::SetupComplete,
api::GetMetaDataRequest::FirstProcessorConnected => DBEnum::FirstProcessorConnected,
api::GetMetaDataRequest::SecondProcessorConnected => DBEnum::SecondProcessorConnected,
api::GetMetaDataRequest::ConfiguredRouting => DBEnum::ConfiguredRouting,
api::GetMetaDataRequest::TestPayment => DBEnum::TestPayment,
api::GetMetaDataRequest::IntegrationMethod => DBEnum::IntegrationMethod,
api::GetMetaDataRequest::ConfigurationType => DBEnum::ConfigurationType,
api::GetMetaDataRequest::IntegrationCompleted => DBEnum::IntegrationCompleted,
api::GetMetaDataRequest::StripeConnected => DBEnum::StripeConnected,
api::GetMetaDataRequest::PaypalConnected => DBEnum::PaypalConnected,
api::GetMetaDataRequest::SPRoutingConfigured => DBEnum::SpRoutingConfigured,
api::GetMetaDataRequest::Feedback => DBEnum::Feedback,
api::GetMetaDataRequest::ProdIntent => DBEnum::ProdIntent,
api::GetMetaDataRequest::SPTestPayment => DBEnum::SpTestPayment,
api::GetMetaDataRequest::DownloadWoocom => DBEnum::DownloadWoocom,
api::GetMetaDataRequest::ConfigureWoocom => DBEnum::ConfigureWoocom,
api::GetMetaDataRequest::SetupWoocomWebhook => DBEnum::SetupWoocomWebhook,
api::GetMetaDataRequest::IsMultipleConfiguration => DBEnum::IsMultipleConfiguration,
api::GetMetaDataRequest::IsChangePasswordRequired => DBEnum::IsChangePasswordRequired,
api::GetMetaDataRequest::OnboardingSurvey => DBEnum::OnboardingSurvey,
api::GetMetaDataRequest::ReconStatus => DBEnum::ReconStatus,
}
}
fn into_response(
data: Option<&DashboardMetadata>,
data_type: DBEnum,
) -> UserResult<api::GetMetaDataResponse> {
match data_type {
DBEnum::ProductionAgreement => Ok(api::GetMetaDataResponse::ProductionAgreement(
data.is_some(),
)),
DBEnum::SetupProcessor => {
let resp = utils::deserialize_to_response(data)?;
Ok(api::GetMetaDataResponse::SetupProcessor(resp))
}
DBEnum::ConfigureEndpoint => {
Ok(api::GetMetaDataResponse::ConfigureEndpoint(data.is_some()))
}
DBEnum::SetupComplete => Ok(api::GetMetaDataResponse::SetupComplete(data.is_some())),
DBEnum::FirstProcessorConnected => {
let resp = utils::deserialize_to_response(data)?;
Ok(api::GetMetaDataResponse::FirstProcessorConnected(resp))
}
DBEnum::SecondProcessorConnected => {
let resp = utils::deserialize_to_response(data)?;
Ok(api::GetMetaDataResponse::SecondProcessorConnected(resp))
}
DBEnum::ConfiguredRouting => {
let resp = utils::deserialize_to_response(data)?;
Ok(api::GetMetaDataResponse::ConfiguredRouting(resp))
}
DBEnum::TestPayment => {
let resp = utils::deserialize_to_response(data)?;
Ok(api::GetMetaDataResponse::TestPayment(resp))
}
DBEnum::IntegrationMethod => {
let resp = utils::deserialize_to_response(data)?;
Ok(api::GetMetaDataResponse::IntegrationMethod(resp))
}
DBEnum::ConfigurationType => {
let resp = utils::deserialize_to_response(data)?;
Ok(api::GetMetaDataResponse::ConfigurationType(resp))
}
DBEnum::IntegrationCompleted => Ok(api::GetMetaDataResponse::IntegrationCompleted(
data.is_some(),
)),
DBEnum::StripeConnected => {
let resp = utils::deserialize_to_response(data)?;
Ok(api::GetMetaDataResponse::StripeConnected(resp))
}
DBEnum::PaypalConnected => {
let resp = utils::deserialize_to_response(data)?;
Ok(api::GetMetaDataResponse::PaypalConnected(resp))
}
DBEnum::SpRoutingConfigured => {
let resp = utils::deserialize_to_response(data)?;
Ok(api::GetMetaDataResponse::SPRoutingConfigured(resp))
}
DBEnum::Feedback => {
let resp = utils::deserialize_to_response(data)?;
Ok(api::GetMetaDataResponse::Feedback(resp))
}
DBEnum::ProdIntent => {
let resp = utils::deserialize_to_response(data)?;
Ok(api::GetMetaDataResponse::ProdIntent(resp))
}
DBEnum::SpTestPayment => Ok(api::GetMetaDataResponse::SPTestPayment(data.is_some())),
DBEnum::DownloadWoocom => Ok(api::GetMetaDataResponse::DownloadWoocom(data.is_some())),
DBEnum::ConfigureWoocom => Ok(api::GetMetaDataResponse::ConfigureWoocom(data.is_some())),
DBEnum::SetupWoocomWebhook => {
Ok(api::GetMetaDataResponse::SetupWoocomWebhook(data.is_some()))
}
DBEnum::IsMultipleConfiguration => Ok(api::GetMetaDataResponse::IsMultipleConfiguration(
data.is_some(),
)),
DBEnum::IsChangePasswordRequired => Ok(api::GetMetaDataResponse::IsChangePasswordRequired(
data.is_some(),
)),
DBEnum::OnboardingSurvey => {
let resp = utils::deserialize_to_response(data)?;
Ok(api::GetMetaDataResponse::OnboardingSurvey(resp))
}
DBEnum::ReconStatus => {
let resp = utils::deserialize_to_response(data)?;
Ok(api::GetMetaDataResponse::ReconStatus(resp))
}
}
}
async fn insert_metadata(
state: &SessionState,
user: UserFromToken,
metadata_key: DBEnum,
metadata_value: types::MetaData,
) -> UserResult<DashboardMetadata> {
match metadata_value {
types::MetaData::ProductionAgreement(data) => {
utils::insert_merchant_scoped_metadata_to_db(
state,
user.user_id,
user.merchant_id,
user.org_id,
metadata_key,
data,
)
.await
}
types::MetaData::SetupProcessor(data) => {
utils::insert_merchant_scoped_metadata_to_db(
state,
user.user_id,
user.merchant_id,
user.org_id,
metadata_key,
data,
)
.await
}
types::MetaData::ConfigureEndpoint(data) => {
utils::insert_merchant_scoped_metadata_to_db(
state,
user.user_id,
user.merchant_id,
user.org_id,
metadata_key,
data,
)
.await
}
types::MetaData::SetupComplete(data) => {
utils::insert_merchant_scoped_metadata_to_db(
state,
user.user_id,
user.merchant_id,
user.org_id,
metadata_key,
data,
)
.await
}
types::MetaData::FirstProcessorConnected(data) => {
utils::insert_merchant_scoped_metadata_to_db(
state,
user.user_id,
user.merchant_id,
user.org_id,
metadata_key,
data,
)
.await
}
types::MetaData::SecondProcessorConnected(data) => {
utils::insert_merchant_scoped_metadata_to_db(
state,
user.user_id,
user.merchant_id,
user.org_id,
metadata_key,
data,
)
.await
}
types::MetaData::ConfiguredRouting(data) => {
utils::insert_merchant_scoped_metadata_to_db(
state,
user.user_id,
user.merchant_id,
user.org_id,
metadata_key,
data,
)
.await
}
types::MetaData::TestPayment(data) => {
utils::insert_merchant_scoped_metadata_to_db(
state,
user.user_id,
user.merchant_id,
user.org_id,
metadata_key,
data,
)
.await
}
types::MetaData::IntegrationMethod(data) => {
let mut metadata = utils::insert_merchant_scoped_metadata_to_db(
state,
user.user_id.clone(),
user.merchant_id.clone(),
user.org_id.clone(),
metadata_key,
data.clone(),
)
.await;
if utils::is_update_required(&metadata) {
metadata = utils::update_merchant_scoped_metadata(
state,
user.user_id,
user.merchant_id,
user.org_id,
metadata_key,
data,
)
.await
.change_context(UserErrors::InternalServerError);
}
metadata
}
types::MetaData::ConfigurationType(data) => {
let mut metadata = utils::insert_merchant_scoped_metadata_to_db(
state,
user.user_id.clone(),
user.merchant_id.clone(),
user.org_id.clone(),
metadata_key,
data.clone(),
)
.await;
if utils::is_update_required(&metadata) {
metadata = utils::update_merchant_scoped_metadata(
state,
user.user_id,
user.merchant_id,
user.org_id,
metadata_key,
data,
)
.await
.change_context(UserErrors::InternalServerError);
}
metadata
}
types::MetaData::IntegrationCompleted(data) => {
utils::insert_merchant_scoped_metadata_to_db(
state,
user.user_id,
user.merchant_id,
user.org_id,
metadata_key,
data,
)
.await
}
types::MetaData::StripeConnected(data) => {
utils::insert_merchant_scoped_metadata_to_db(
state,
user.user_id,
user.merchant_id,
user.org_id,
metadata_key,
data,
)
.await
}
types::MetaData::PaypalConnected(data) => {
utils::insert_merchant_scoped_metadata_to_db(
state,
user.user_id,
user.merchant_id,
user.org_id,
metadata_key,
data,
)
.await
}
types::MetaData::SPRoutingConfigured(data) => {
utils::insert_merchant_scoped_metadata_to_db(
state,
user.user_id,
user.merchant_id,
user.org_id,
metadata_key,
data,
)
.await
}
types::MetaData::Feedback(data) => {
let mut metadata = utils::insert_user_scoped_metadata_to_db(
state,
user.user_id.clone(),
user.merchant_id.clone(),
user.org_id.clone(),
metadata_key,
data.clone(),
)
.await;
if utils::is_update_required(&metadata) {
metadata = utils::update_user_scoped_metadata(
state,
user.user_id,
user.merchant_id,
user.org_id,
metadata_key,
data,
)
.await
.change_context(UserErrors::InternalServerError);
}
metadata
}
types::MetaData::ProdIntent(data) => {
let mut metadata = utils::insert_merchant_scoped_metadata_to_db(
state,
user.user_id.clone(),
user.merchant_id.clone(),
user.org_id.clone(),
metadata_key,
data.clone(),
)
.await;
if utils::is_update_required(&metadata) {
metadata = utils::update_merchant_scoped_metadata(
state,
user.user_id.clone(),
user.merchant_id.clone(),
user.org_id.clone(),
metadata_key,
data.clone(),
)
.await
.change_context(UserErrors::InternalServerError);
}
#[cfg(feature = "email")]
{
let user_data = user.get_user_from_db(state).await?;
let user_email = domain::UserEmail::from_pii_email(user_data.get_email())
.change_context(UserErrors::InternalServerError)?
.get_secret()
.expose();
if utils::is_prod_email_required(&data, user_email) {
let theme = theme_utils::get_most_specific_theme_using_token_and_min_entity(
state,
&user,
EntityType::Merchant,
)
.await?;
let email_contents = email_types::BizEmailProd::new(
state,
data.clone(),
theme.as_ref().map(|theme| theme.theme_id.clone()),
theme
.map(|theme| theme.email_config())
.unwrap_or(state.conf.theme.email_config.clone()),
)?;
let send_email_result = state
.email_client
.compose_and_send_email(
user_utils::get_base_url(state),
Box::new(email_contents),
state.conf.proxy.https_url.as_ref(),
)
.await;
logger::info!(prod_intent_email=?send_email_result);
}
}
// Hubspot integration
let hubspot_body = state
.crm_client
.make_body(CrmPayload {
legal_business_name: data.legal_business_name.map(|s| s.into_inner()),
business_label: data.business_label.map(|s| s.into_inner()),
business_location: data.business_location,
display_name: data.display_name.map(|s| s.into_inner()),
poc_email: data.poc_email.map(|s| Secret::new(s.peek().clone())),
business_type: data.business_type.map(|s| s.into_inner()),
business_identifier: data.business_identifier.map(|s| s.into_inner()),
business_website: data.business_website.map(|s| s.into_inner()),
poc_name: data
.poc_name
.map(|s| Secret::new(s.peek().clone().into_inner())),
poc_contact: data
.poc_contact
.map(|s| Secret::new(s.peek().clone().into_inner())),
comments: data.comments.map(|s| s.into_inner()),
is_completed: data.is_completed,
business_country_name: data.business_country_name.map(|s| s.into_inner()),
})
.await;
let base_url = user_utils::get_base_url(state);
let hubspot_request = state
.crm_client
.make_request(hubspot_body, base_url.to_string())
.await;
let _ = state
.crm_client
.send_request(&state.conf.proxy, hubspot_request)
.await
.inspect_err(|err| {
logger::error!(
"An error occurred while sending data to hubspot for user_id {}: {:?}",
user.user_id,
err
);
});
metadata
}
types::MetaData::SPTestPayment(data) => {
utils::insert_merchant_scoped_metadata_to_db(
state,
user.user_id,
user.merchant_id,
user.org_id,
metadata_key,
data,
)
.await
}
types::MetaData::DownloadWoocom(data) => {
utils::insert_merchant_scoped_metadata_to_db(
state,
user.user_id,
user.merchant_id,
user.org_id,
metadata_key,
data,
)
.await
}
types::MetaData::ConfigureWoocom(data) => {
utils::insert_merchant_scoped_metadata_to_db(
state,
user.user_id,
user.merchant_id,
user.org_id,
metadata_key,
data,
)
.await
}
types::MetaData::SetupWoocomWebhook(data) => {
utils::insert_merchant_scoped_metadata_to_db(
state,
user.user_id,
user.merchant_id,
user.org_id,
metadata_key,
data,
)
.await
}
types::MetaData::IsMultipleConfiguration(data) => {
utils::insert_merchant_scoped_metadata_to_db(
state,
user.user_id,
user.merchant_id,
user.org_id,
metadata_key,
data,
)
.await
}
types::MetaData::IsChangePasswordRequired(data) => {
utils::insert_user_scoped_metadata_to_db(
state,
user.user_id,
user.merchant_id,
user.org_id,
metadata_key,
data,
)
.await
}
types::MetaData::OnboardingSurvey(data) => {
utils::insert_merchant_scoped_metadata_to_db(
state,
user.user_id,
user.merchant_id,
user.org_id,
metadata_key,
data,
)
.await
}
types::MetaData::ReconStatus(data) => {
let mut metadata = utils::insert_merchant_scoped_metadata_to_db(
state,
user.user_id.clone(),
user.merchant_id.clone(),
user.org_id.clone(),
metadata_key,
data.clone(),
)
.await;
if utils::is_update_required(&metadata) {
metadata = utils::update_merchant_scoped_metadata(
state,
user.user_id,
user.merchant_id,
user.org_id,
metadata_key,
data,
)
.await;
}
metadata
}
}
}
async fn fetch_metadata(
state: &SessionState,
user: &UserFromToken,
metadata_keys: Vec<DBEnum>,
) -> UserResult<Vec<DashboardMetadata>> {
let mut dashboard_metadata = Vec::with_capacity(metadata_keys.len());
let (merchant_scoped_enums, user_scoped_enums) =
utils::separate_metadata_type_based_on_scope(metadata_keys);
if !merchant_scoped_enums.is_empty() {
let mut res = utils::get_merchant_scoped_metadata_from_db(
state,
user.merchant_id.to_owned(),
user.org_id.to_owned(),
merchant_scoped_enums,
)
.await?;
dashboard_metadata.append(&mut res);
}
if !user_scoped_enums.is_empty() {
let mut res = utils::get_user_scoped_metadata_from_db(
state,
user.user_id.to_owned(),
user.merchant_id.to_owned(),
user.org_id.to_owned(),
user_scoped_enums,
)
.await?;
dashboard_metadata.append(&mut res);
}
Ok(dashboard_metadata)
}
pub async fn backfill_metadata(
state: &SessionState,
user: &UserFromToken,
key: &DBEnum,
) -> UserResult<Option<DashboardMetadata>> {
let key_store = state
.store
.get_merchant_key_store_by_merchant_id(
&user.merchant_id,
&state.store.get_master_key().to_vec().into(),
)
.await
.change_context(UserErrors::InternalServerError)?;
match key {
DBEnum::StripeConnected => {
let mca = if let Some(stripe_connected) = get_merchant_connector_account_by_name(
state,
&user.merchant_id,
api_models::enums::RoutableConnectors::Stripe
.to_string()
.as_str(),
&key_store,
)
.await?
{
stripe_connected
} else if let Some(stripe_test_connected) = get_merchant_connector_account_by_name(
state,
&user.merchant_id,
//TODO: Use Enum with proper feature flag
"stripe_test",
&key_store,
)
.await?
{
stripe_test_connected
} else {
return Ok(None);
};
#[cfg(feature = "v1")]
let processor_name = mca.connector_name.clone();
#[cfg(feature = "v2")]
let processor_name = mca.connector_name.to_string().clone();
Some(
insert_metadata(
state,
user.to_owned(),
DBEnum::StripeConnected,
types::MetaData::StripeConnected(api::ProcessorConnected {
processor_id: mca.get_id(),
processor_name,
}),
)
.await,
)
.transpose()
}
DBEnum::PaypalConnected => {
let mca = if let Some(paypal_connected) = get_merchant_connector_account_by_name(
state,
&user.merchant_id,
api_models::enums::RoutableConnectors::Paypal
.to_string()
.as_str(),
&key_store,
)
.await?
{
paypal_connected
} else if let Some(paypal_test_connected) = get_merchant_connector_account_by_name(
state,
&user.merchant_id,
//TODO: Use Enum with proper feature flag
"paypal_test",
&key_store,
)
.await?
{
paypal_test_connected
} else {
return Ok(None);
};
#[cfg(feature = "v1")]
let processor_name = mca.connector_name.clone();
#[cfg(feature = "v2")]
let processor_name = mca.connector_name.to_string().clone();
Some(
insert_metadata(
state,
user.to_owned(),
DBEnum::PaypalConnected,
types::MetaData::PaypalConnected(api::ProcessorConnected {
processor_id: mca.get_id(),
processor_name,
}),
)
.await,
)
.transpose()
}
_ => Ok(None),
}
}
pub async fn get_merchant_connector_account_by_name(
state: &SessionState,
merchant_id: &common_utils::id_type::MerchantId,
connector_name: &str,
key_store: &MerchantKeyStore,
) -> UserResult<Option<domain::MerchantConnectorAccount>> {
#[cfg(feature = "v1")]
{
state
.store
.find_merchant_connector_account_by_merchant_id_connector_name(
merchant_id,
connector_name,
key_store,
)
.await
.map_err(|e| {
e.change_context(UserErrors::InternalServerError)
.attach_printable("DB Error Fetching DashboardMetaData")
})
.map(|data| data.first().cloned())
}
#[cfg(feature = "v2")]
{
let _ = state;
let _ = merchant_id;
let _ = connector_name;
let _ = key_store;
todo!()
}
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/relay/utils.rs | crates/router/src/core/relay/utils.rs | use std::str::FromStr;
use common_utils::{ext_traits::OptionExt, id_type};
use error_stack::ResultExt;
use hyperswitch_domain_models::{router_data::ErrorResponse, types};
use crate::{
core::payments,
db::{
domain,
errors::{self, RouterResult},
},
routes::SessionState,
};
const IRRELEVANT_PAYMENT_INTENT_ID: &str = "irrelevant_payment_intent_id";
const IRRELEVANT_PAYMENT_ATTEMPT_ID: &str = "irrelevant_payment_attempt_id";
pub async fn construct_relay_refund_router_data<F>(
state: &SessionState,
merchant_id: &id_type::MerchantId,
connector_account: &domain::MerchantConnectorAccount,
relay_record: &hyperswitch_domain_models::relay::Relay,
) -> RouterResult<types::RefundsRouterData<F>> {
let connector_auth_type = connector_account
.get_connector_account_details()
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed while parsing value for ConnectorAuthType")?;
#[cfg(feature = "v2")]
let connector_name = &connector_account.connector_name.to_string();
#[cfg(feature = "v1")]
let connector_name = &connector_account.connector_name;
let webhook_url = Some(payments::helpers::create_webhook_url(
&state.base_url.clone(),
merchant_id,
connector_account.get_id().get_string_repr(),
));
let supported_connector = &state
.conf
.multiple_api_version_supported_connectors
.supported_connectors;
let connector_enum = api_models::enums::Connector::from_str(connector_name)
.change_context(errors::ConnectorError::InvalidConnectorName)
.change_context(errors::ApiErrorResponse::InvalidDataValue {
field_name: "connector",
})
.attach_printable_lazy(|| format!("unable to parse connector name {connector_name:?}"))?;
let connector_api_version = if supported_connector.contains(&connector_enum) {
state
.store
.find_config_by_key(&format!("connector_api_version_{connector_name}"))
.await
.map(|value| value.config)
.ok()
} else {
None
};
let hyperswitch_domain_models::relay::RelayData::Refund(relay_refund_data) = relay_record
.request_data
.clone()
.get_required_value("refund relay data")
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed to obtain relay data to construct relay refund data")?;
let relay_id_string = relay_record.id.get_string_repr().to_string();
let router_data = hyperswitch_domain_models::router_data::RouterData {
flow: std::marker::PhantomData,
merchant_id: merchant_id.clone(),
customer_id: None,
tenant_id: state.tenant.tenant_id.clone(),
connector: connector_name.to_string(),
payment_id: IRRELEVANT_PAYMENT_INTENT_ID.to_string(),
attempt_id: IRRELEVANT_PAYMENT_ATTEMPT_ID.to_string(),
status: common_enums::AttemptStatus::Charged,
payment_method: common_enums::PaymentMethod::default(),
payment_method_type: None,
connector_auth_type,
description: None,
address: hyperswitch_domain_models::payment_address::PaymentAddress::default(),
auth_type: common_enums::AuthenticationType::default(),
connector_meta_data: connector_account.metadata.clone(),
connector_wallets_details: None,
amount_captured: None,
payment_method_status: None,
minor_amount_captured: None,
request: hyperswitch_domain_models::router_request_types::RefundsData {
refund_id: relay_id_string.clone(),
connector_transaction_id: relay_record.connector_resource_id.clone(),
refund_amount: relay_refund_data.amount.get_amount_as_i64(),
minor_refund_amount: relay_refund_data.amount,
currency: relay_refund_data.currency,
payment_amount: relay_refund_data.amount.get_amount_as_i64(),
minor_payment_amount: relay_refund_data.amount,
webhook_url,
connector_metadata: None,
refund_connector_metadata: None,
reason: relay_refund_data.reason,
connector_refund_id: relay_record.connector_reference_id.clone(),
browser_info: None,
split_refunds: None,
integrity_object: None,
refund_status: common_enums::RefundStatus::from(relay_record.status),
merchant_account_id: None,
merchant_config_currency: None,
capture_method: None,
additional_payment_method_data: None,
},
response: Err(ErrorResponse::default()),
access_token: None,
session_token: None,
reference_id: None,
payment_method_token: None,
connector_customer: None,
recurring_mandate_payment_data: None,
preprocessing_id: None,
connector_request_reference_id: relay_id_string.clone(),
#[cfg(feature = "payouts")]
payout_method_data: None,
#[cfg(feature = "payouts")]
quote_id: None,
test_mode: connector_account.get_connector_test_mode(),
payment_method_balance: None,
connector_api_version,
connector_http_status_code: None,
external_latency: None,
apple_pay_flow: None,
frm_metadata: None,
refund_id: Some(relay_id_string),
dispute_id: None,
payout_id: None,
connector_response: None,
integrity_check: Ok(()),
additional_merchant_data: None,
header_payload: None,
connector_mandate_request_reference_id: None,
authentication_id: None,
psd2_sca_exemption_type: None,
raw_connector_response: None,
is_payment_id_from_merchant: None,
l2_l3_data: None,
minor_amount_capturable: None,
authorized_amount: None,
};
Ok(router_data)
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/errors/user.rs | crates/router/src/core/errors/user.rs | use common_utils::errors::CustomResult;
use crate::services::ApplicationResponse;
pub type UserResult<T> = CustomResult<T, UserErrors>;
pub type UserResponse<T> = CustomResult<ApplicationResponse<T>, UserErrors>;
pub mod sample_data;
#[derive(Debug, thiserror::Error)]
pub enum UserErrors {
#[error("User InternalServerError")]
InternalServerError,
#[error("InvalidCredentials")]
InvalidCredentials,
#[error("UserNotFound")]
UserNotFound,
#[error("UserExists")]
UserExists,
#[error("LinkInvalid")]
LinkInvalid,
#[error("UnverifiedUser")]
UnverifiedUser,
#[error("InvalidOldPassword")]
InvalidOldPassword,
#[error("EmailParsingError")]
EmailParsingError,
#[error("NameParsingError")]
NameParsingError,
#[error("PasswordParsingError")]
PasswordParsingError,
#[error("UserAlreadyVerified")]
UserAlreadyVerified,
#[error("CompanyNameParsingError")]
CompanyNameParsingError,
#[error("MerchantAccountCreationError: {0}")]
MerchantAccountCreationError(String),
#[error("InvalidEmailError")]
InvalidEmailError,
#[error("DuplicateOrganizationId")]
DuplicateOrganizationId,
#[error("MerchantIdNotFound")]
MerchantIdNotFound,
#[error("MetadataAlreadySet")]
MetadataAlreadySet,
#[error("InvalidRoleId")]
InvalidRoleId,
#[error("InvalidRoleOperation")]
InvalidRoleOperation,
#[error("IpAddressParsingFailed")]
IpAddressParsingFailed,
#[error("InvalidMetadataRequest")]
InvalidMetadataRequest,
#[error("MerchantIdParsingError")]
MerchantIdParsingError,
#[error("ChangePasswordError")]
ChangePasswordError,
#[error("InvalidDeleteOperation")]
InvalidDeleteOperation,
#[error("MaxInvitationsError")]
MaxInvitationsError,
#[error("RoleNotFound")]
RoleNotFound,
#[error("InvalidRoleOperationWithMessage")]
InvalidRoleOperationWithMessage(String),
#[error("RoleNameParsingError")]
RoleNameParsingError,
#[error("RoleNameAlreadyExists")]
RoleNameAlreadyExists,
#[error("TotpNotSetup")]
TotpNotSetup,
#[error("InvalidTotp")]
InvalidTotp,
#[error("TotpRequired")]
TotpRequired,
#[error("InvalidRecoveryCode")]
InvalidRecoveryCode,
#[error("TwoFactorAuthRequired")]
TwoFactorAuthRequired,
#[error("TwoFactorAuthNotSetup")]
TwoFactorAuthNotSetup,
#[error("TOTP secret not found")]
TotpSecretNotFound,
#[error("User auth method already exists")]
UserAuthMethodAlreadyExists,
#[error("Invalid user auth method operation")]
InvalidUserAuthMethodOperation,
#[error("Auth config parsing error")]
AuthConfigParsingError,
#[error("Invalid SSO request")]
SSOFailed,
#[error("profile_id missing in JWT")]
JwtProfileIdMissing,
#[error("Maximum attempts reached for TOTP")]
MaxTotpAttemptsReached,
#[error("Maximum attempts reached for Recovery Code")]
MaxRecoveryCodeAttemptsReached,
#[error("Forbidden tenant id")]
ForbiddenTenantId,
#[error("Error Uploading file to Theme Storage")]
ErrorUploadingFile,
#[error("Error Retrieving file from Theme Storage")]
ErrorRetrievingFile,
#[error("Theme not found")]
ThemeNotFound,
#[error("Theme with lineage already exists")]
ThemeAlreadyExists,
#[error("Invalid field: {0} in lineage")]
InvalidThemeLineage(String),
#[error("Missing required field: email_config")]
MissingEmailConfig,
#[error("Invalid Auth Method Operation: {0}")]
InvalidAuthMethodOperationWithMessage(String),
#[error("Invalid Clone Connector Operation: {0}")]
InvalidCloneConnectorOperation(String),
#[error("Error cloning connector: {0}")]
ErrorCloningConnector(String),
}
impl common_utils::errors::ErrorSwitch<api_models::errors::types::ApiErrorResponse> for UserErrors {
fn switch(&self) -> api_models::errors::types::ApiErrorResponse {
use api_models::errors::types::{ApiError, ApiErrorResponse as AER};
let sub_code = "UR";
match self {
Self::InternalServerError => {
AER::InternalServerError(ApiError::new("HE", 0, self.get_error_message(), None))
}
Self::InvalidCredentials => {
AER::Unauthorized(ApiError::new(sub_code, 1, self.get_error_message(), None))
}
Self::UserNotFound => {
AER::Unauthorized(ApiError::new(sub_code, 2, self.get_error_message(), None))
}
Self::UserExists => {
AER::BadRequest(ApiError::new(sub_code, 3, self.get_error_message(), None))
}
Self::LinkInvalid => {
AER::Unauthorized(ApiError::new(sub_code, 4, self.get_error_message(), None))
}
Self::UnverifiedUser => {
AER::Unauthorized(ApiError::new(sub_code, 5, self.get_error_message(), None))
}
Self::InvalidOldPassword => {
AER::BadRequest(ApiError::new(sub_code, 6, self.get_error_message(), None))
}
Self::EmailParsingError => {
AER::BadRequest(ApiError::new(sub_code, 7, self.get_error_message(), None))
}
Self::NameParsingError => {
AER::BadRequest(ApiError::new(sub_code, 8, self.get_error_message(), None))
}
Self::PasswordParsingError => {
AER::BadRequest(ApiError::new(sub_code, 9, self.get_error_message(), None))
}
Self::UserAlreadyVerified => {
AER::Unauthorized(ApiError::new(sub_code, 11, self.get_error_message(), None))
}
Self::CompanyNameParsingError => {
AER::BadRequest(ApiError::new(sub_code, 14, self.get_error_message(), None))
}
Self::MerchantAccountCreationError(_) => AER::InternalServerError(ApiError::new(
sub_code,
15,
self.get_error_message(),
None,
)),
Self::InvalidEmailError => {
AER::BadRequest(ApiError::new(sub_code, 16, self.get_error_message(), None))
}
Self::MerchantIdNotFound => {
AER::BadRequest(ApiError::new(sub_code, 18, self.get_error_message(), None))
}
Self::MetadataAlreadySet => {
AER::BadRequest(ApiError::new(sub_code, 19, self.get_error_message(), None))
}
Self::DuplicateOrganizationId => AER::InternalServerError(ApiError::new(
sub_code,
21,
self.get_error_message(),
None,
)),
Self::InvalidRoleId => {
AER::BadRequest(ApiError::new(sub_code, 22, self.get_error_message(), None))
}
Self::InvalidRoleOperation => {
AER::BadRequest(ApiError::new(sub_code, 23, self.get_error_message(), None))
}
Self::IpAddressParsingFailed => AER::InternalServerError(ApiError::new(
sub_code,
24,
self.get_error_message(),
None,
)),
Self::InvalidMetadataRequest => {
AER::BadRequest(ApiError::new(sub_code, 26, self.get_error_message(), None))
}
Self::MerchantIdParsingError => {
AER::BadRequest(ApiError::new(sub_code, 28, self.get_error_message(), None))
}
Self::ChangePasswordError => {
AER::BadRequest(ApiError::new(sub_code, 29, self.get_error_message(), None))
}
Self::InvalidDeleteOperation => {
AER::BadRequest(ApiError::new(sub_code, 30, self.get_error_message(), None))
}
Self::MaxInvitationsError => {
AER::BadRequest(ApiError::new(sub_code, 31, self.get_error_message(), None))
}
Self::RoleNotFound => {
AER::BadRequest(ApiError::new(sub_code, 32, self.get_error_message(), None))
}
Self::InvalidRoleOperationWithMessage(_) => {
AER::BadRequest(ApiError::new(sub_code, 33, self.get_error_message(), None))
}
Self::RoleNameParsingError => {
AER::BadRequest(ApiError::new(sub_code, 34, self.get_error_message(), None))
}
Self::RoleNameAlreadyExists => {
AER::BadRequest(ApiError::new(sub_code, 35, self.get_error_message(), None))
}
Self::TotpNotSetup => {
AER::BadRequest(ApiError::new(sub_code, 36, self.get_error_message(), None))
}
Self::InvalidTotp => {
AER::BadRequest(ApiError::new(sub_code, 37, self.get_error_message(), None))
}
Self::TotpRequired => {
AER::BadRequest(ApiError::new(sub_code, 38, self.get_error_message(), None))
}
Self::InvalidRecoveryCode => {
AER::BadRequest(ApiError::new(sub_code, 39, self.get_error_message(), None))
}
Self::TwoFactorAuthRequired => {
AER::BadRequest(ApiError::new(sub_code, 40, self.get_error_message(), None))
}
Self::TwoFactorAuthNotSetup => {
AER::BadRequest(ApiError::new(sub_code, 41, self.get_error_message(), None))
}
Self::TotpSecretNotFound => {
AER::BadRequest(ApiError::new(sub_code, 42, self.get_error_message(), None))
}
Self::UserAuthMethodAlreadyExists => {
AER::BadRequest(ApiError::new(sub_code, 43, self.get_error_message(), None))
}
Self::InvalidUserAuthMethodOperation => {
AER::BadRequest(ApiError::new(sub_code, 44, self.get_error_message(), None))
}
Self::AuthConfigParsingError => {
AER::BadRequest(ApiError::new(sub_code, 45, self.get_error_message(), None))
}
Self::SSOFailed => {
AER::BadRequest(ApiError::new(sub_code, 46, self.get_error_message(), None))
}
Self::JwtProfileIdMissing => {
AER::Unauthorized(ApiError::new(sub_code, 47, self.get_error_message(), None))
}
Self::MaxTotpAttemptsReached => {
AER::BadRequest(ApiError::new(sub_code, 48, self.get_error_message(), None))
}
Self::MaxRecoveryCodeAttemptsReached => {
AER::BadRequest(ApiError::new(sub_code, 49, self.get_error_message(), None))
}
Self::ForbiddenTenantId => {
AER::BadRequest(ApiError::new(sub_code, 50, self.get_error_message(), None))
}
Self::ErrorUploadingFile => AER::InternalServerError(ApiError::new(
sub_code,
51,
self.get_error_message(),
None,
)),
Self::ErrorRetrievingFile => AER::InternalServerError(ApiError::new(
sub_code,
52,
self.get_error_message(),
None,
)),
Self::ThemeNotFound => {
AER::NotFound(ApiError::new(sub_code, 53, self.get_error_message(), None))
}
Self::ThemeAlreadyExists => {
AER::BadRequest(ApiError::new(sub_code, 54, self.get_error_message(), None))
}
Self::InvalidThemeLineage(_) => {
AER::BadRequest(ApiError::new(sub_code, 55, self.get_error_message(), None))
}
Self::MissingEmailConfig => {
AER::BadRequest(ApiError::new(sub_code, 56, self.get_error_message(), None))
}
Self::InvalidAuthMethodOperationWithMessage(_) => {
AER::BadRequest(ApiError::new(sub_code, 57, self.get_error_message(), None))
}
Self::InvalidCloneConnectorOperation(_) => {
AER::BadRequest(ApiError::new(sub_code, 58, self.get_error_message(), None))
}
Self::ErrorCloningConnector(_) => AER::InternalServerError(ApiError::new(
sub_code,
59,
self.get_error_message(),
None,
)),
}
}
}
impl UserErrors {
pub fn get_error_message(&self) -> String {
match self {
Self::InternalServerError => "Something went wrong".to_string(),
Self::InvalidCredentials => "Incorrect email or password".to_string(),
Self::UserNotFound => "Email doesn’t exist. Register".to_string(),
Self::UserExists => "An account already exists with this email".to_string(),
Self::LinkInvalid => "Invalid or expired link".to_string(),
Self::UnverifiedUser => "Kindly verify your account".to_string(),
Self::InvalidOldPassword => {
"Old password incorrect. Please enter the correct password".to_string()
}
Self::EmailParsingError => "Invalid Email".to_string(),
Self::NameParsingError => "Invalid Name".to_string(),
Self::PasswordParsingError => "Invalid Password".to_string(),
Self::UserAlreadyVerified => "User already verified".to_string(),
Self::CompanyNameParsingError => "Invalid Company Name".to_string(),
Self::MerchantAccountCreationError(error_message) => error_message.to_string(),
Self::InvalidEmailError => "Invalid Email".to_string(),
Self::MerchantIdNotFound => "Invalid Merchant ID".to_string(),
Self::MetadataAlreadySet => "Metadata already set".to_string(),
Self::DuplicateOrganizationId => {
"An Organization with the id already exists".to_string()
}
Self::InvalidRoleId => "Invalid Role ID".to_string(),
Self::InvalidRoleOperation => "User Role Operation Not Supported".to_string(),
Self::IpAddressParsingFailed => "Something went wrong".to_string(),
Self::InvalidMetadataRequest => "Invalid Metadata Request".to_string(),
Self::MerchantIdParsingError => "Invalid Merchant Id".to_string(),
Self::ChangePasswordError => "Old and new password cannot be same".to_string(),
Self::InvalidDeleteOperation => "Delete Operation Not Supported".to_string(),
Self::MaxInvitationsError => "Maximum invite count per request exceeded".to_string(),
Self::RoleNotFound => "Role Not Found".to_string(),
Self::InvalidRoleOperationWithMessage(error_message) => error_message.to_string(),
Self::RoleNameParsingError => "Invalid Role Name".to_string(),
Self::RoleNameAlreadyExists => "Role name already exists".to_string(),
Self::TotpNotSetup => "TOTP not setup".to_string(),
Self::InvalidTotp => "Invalid TOTP".to_string(),
Self::TotpRequired => "TOTP required".to_string(),
Self::InvalidRecoveryCode => "Invalid Recovery Code".to_string(),
Self::MaxTotpAttemptsReached => "Maximum attempts reached for TOTP".to_string(),
Self::MaxRecoveryCodeAttemptsReached => {
"Maximum attempts reached for Recovery Code".to_string()
}
Self::TwoFactorAuthRequired => "Two factor auth required".to_string(),
Self::TwoFactorAuthNotSetup => "Two factor auth not setup".to_string(),
Self::TotpSecretNotFound => "TOTP secret not found".to_string(),
Self::UserAuthMethodAlreadyExists => "User auth method already exists".to_string(),
Self::InvalidUserAuthMethodOperation => {
"Invalid user auth method operation".to_string()
}
Self::AuthConfigParsingError => "Auth config parsing error".to_string(),
Self::SSOFailed => "Invalid SSO request".to_string(),
Self::JwtProfileIdMissing => "profile_id missing in JWT".to_string(),
Self::ForbiddenTenantId => "Forbidden tenant id".to_string(),
Self::ErrorUploadingFile => "Error Uploading file to Theme Storage".to_string(),
Self::ErrorRetrievingFile => "Error Retrieving file from Theme Storage".to_string(),
Self::ThemeNotFound => "Theme not found".to_string(),
Self::ThemeAlreadyExists => "Theme with lineage already exists".to_string(),
Self::InvalidThemeLineage(field_name) => {
format!("Invalid field: {field_name} in lineage")
}
Self::MissingEmailConfig => "Missing required field: email_config".to_string(),
Self::InvalidAuthMethodOperationWithMessage(operation) => {
format!("Invalid Auth Method Operation: {operation}")
}
Self::InvalidCloneConnectorOperation(operation) => {
format!("Invalid Clone Connector Operation: {operation}")
}
Self::ErrorCloningConnector(error_message) => {
format!("Error cloning connector: {error_message}")
}
}
}
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/errors/error_handlers.rs | crates/router/src/core/errors/error_handlers.rs | use actix_web::{body, dev::ServiceResponse, middleware::ErrorHandlerResponse, ResponseError};
use http::StatusCode;
use super::ApiErrorResponse;
use crate::logger;
pub fn custom_error_handlers<B: body::MessageBody + 'static>(
res: ServiceResponse<B>,
) -> actix_web::Result<ErrorHandlerResponse<B>> {
let error_response = match res.status() {
StatusCode::NOT_FOUND => ApiErrorResponse::InvalidRequestUrl,
StatusCode::METHOD_NOT_ALLOWED => ApiErrorResponse::InvalidHttpMethod,
_ => ApiErrorResponse::InternalServerError,
};
let (req, res) = res.into_parts();
logger::warn!(error_response=?res);
let res = match res.error() {
Some(_) => res.map_into_boxed_body(),
None => error_response.error_response(),
};
let res = ServiceResponse::new(req, res)
.map_into_boxed_body()
.map_into_right_body();
Ok(ErrorHandlerResponse::Response(res))
}
// can be used as .default_service for web::resource to modify the default behavior of method_not_found error i.e. raised
// use actix_web::dev::ServiceRequest
// pub async fn default_service_405<E>(req: ServiceRequest) -> Result<ServiceResponse, E> {
// Ok(req.into_response(ApiErrorResponse::InvalidHttpMethod.error_response()))
// }
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/errors/utils.rs | crates/router/src/core/errors/utils.rs | use common_utils::errors::CustomResult;
use crate::{core::errors, logger};
pub trait StorageErrorExt<T, E> {
#[track_caller]
fn to_not_found_response(self, not_found_response: E) -> error_stack::Result<T, E>;
#[track_caller]
fn to_duplicate_response(self, duplicate_response: E) -> error_stack::Result<T, E>;
}
impl<T> StorageErrorExt<T, errors::CustomersErrorResponse>
for error_stack::Result<T, errors::StorageError>
{
#[track_caller]
fn to_not_found_response(
self,
not_found_response: errors::CustomersErrorResponse,
) -> error_stack::Result<T, errors::CustomersErrorResponse> {
self.map_err(|err| match err.current_context() {
error if error.is_db_not_found() => err.change_context(not_found_response),
errors::StorageError::CustomerRedacted => {
err.change_context(errors::CustomersErrorResponse::CustomerRedacted)
}
_ => err.change_context(errors::CustomersErrorResponse::InternalServerError),
})
}
fn to_duplicate_response(
self,
duplicate_response: errors::CustomersErrorResponse,
) -> error_stack::Result<T, errors::CustomersErrorResponse> {
self.map_err(|err| {
if err.current_context().is_db_unique_violation() {
err.change_context(duplicate_response)
} else {
err.change_context(errors::CustomersErrorResponse::InternalServerError)
}
})
}
}
impl<T> StorageErrorExt<T, errors::ApiErrorResponse>
for error_stack::Result<T, errors::StorageError>
{
#[track_caller]
fn to_not_found_response(
self,
not_found_response: errors::ApiErrorResponse,
) -> error_stack::Result<T, errors::ApiErrorResponse> {
self.map_err(|err| {
let new_err = match err.current_context() {
errors::StorageError::ValueNotFound(_) => not_found_response,
errors::StorageError::CustomerRedacted => {
errors::ApiErrorResponse::CustomerRedacted
}
_ => errors::ApiErrorResponse::InternalServerError,
};
err.change_context(new_err)
})
}
#[track_caller]
fn to_duplicate_response(
self,
duplicate_response: errors::ApiErrorResponse,
) -> error_stack::Result<T, errors::ApiErrorResponse> {
self.map_err(|err| {
let new_err = match err.current_context() {
errors::StorageError::DuplicateValue { .. } => duplicate_response,
_ => errors::ApiErrorResponse::InternalServerError,
};
err.change_context(new_err)
})
}
}
pub trait ConnectorErrorExt<T> {
#[track_caller]
fn to_refund_failed_response(self) -> error_stack::Result<T, errors::ApiErrorResponse>;
#[track_caller]
fn to_payment_failed_response(self) -> error_stack::Result<T, errors::ApiErrorResponse>;
#[track_caller]
fn to_setup_mandate_failed_response(self) -> error_stack::Result<T, errors::ApiErrorResponse>;
#[track_caller]
fn to_dispute_failed_response(self) -> error_stack::Result<T, errors::ApiErrorResponse>;
#[track_caller]
fn to_files_failed_response(self) -> error_stack::Result<T, errors::ApiErrorResponse>;
#[cfg(feature = "payouts")]
#[track_caller]
fn to_payout_failed_response(self) -> error_stack::Result<T, errors::ApiErrorResponse>;
#[track_caller]
fn to_vault_failed_response(self) -> error_stack::Result<T, errors::ApiErrorResponse>;
// Validates if the result, is Ok(..) or WebhookEventTypeNotFound all the other error variants
// are cascaded while these two event types are handled via `Option`
#[track_caller]
fn allow_webhook_event_type_not_found(
self,
enabled: bool,
) -> error_stack::Result<Option<T>, errors::ConnectorError>;
}
impl<T> ConnectorErrorExt<T> for error_stack::Result<T, errors::ConnectorError> {
fn to_refund_failed_response(self) -> error_stack::Result<T, errors::ApiErrorResponse> {
self.map_err(|err| match err.current_context() {
errors::ConnectorError::ProcessingStepFailed(Some(bytes)) => {
let response_str = std::str::from_utf8(bytes);
let data = match response_str {
Ok(s) => serde_json::from_str(s)
.map_err(
|error| logger::error!(%error,"Failed to convert response to JSON"),
)
.ok(),
Err(error) => {
logger::error!(%error,"Failed to convert response to UTF8 string");
None
}
};
err.change_context(errors::ApiErrorResponse::RefundFailed { data })
}
errors::ConnectorError::NotImplemented(reason) => {
errors::ApiErrorResponse::NotImplemented {
message: errors::NotImplementedMessage::Reason(reason.to_string()),
}
.into()
}
errors::ConnectorError::NotSupported { message, connector } => {
errors::ApiErrorResponse::NotSupported {
message: format!("{message} is not supported by {connector}"),
}
.into()
}
errors::ConnectorError::CaptureMethodNotSupported => {
errors::ApiErrorResponse::NotSupported {
message: "Capture Method Not Supported".to_owned(),
}
.into()
}
errors::ConnectorError::FailedToObtainIntegrationUrl
| errors::ConnectorError::RequestEncodingFailed
| errors::ConnectorError::RequestEncodingFailedWithReason(_)
| errors::ConnectorError::ParsingFailed
| errors::ConnectorError::ResponseDeserializationFailed
| errors::ConnectorError::UnexpectedResponseError(_)
| errors::ConnectorError::RoutingRulesParsingError
| errors::ConnectorError::FailedToObtainPreferredConnector
| errors::ConnectorError::ProcessingStepFailed(_)
| errors::ConnectorError::InvalidConnectorName
| errors::ConnectorError::InvalidWallet
| errors::ConnectorError::ResponseHandlingFailed
| errors::ConnectorError::MissingRequiredField { .. }
| errors::ConnectorError::MissingRequiredFields { .. }
| errors::ConnectorError::FailedToObtainAuthType
| errors::ConnectorError::FailedToObtainCertificate
| errors::ConnectorError::NoConnectorMetaData
| errors::ConnectorError::NoConnectorWalletDetails
| errors::ConnectorError::FailedToObtainCertificateKey
| errors::ConnectorError::MaxFieldLengthViolated { .. }
| errors::ConnectorError::FlowNotSupported { .. }
| errors::ConnectorError::MissingConnectorMandateID
| errors::ConnectorError::MissingConnectorMandateMetadata
| errors::ConnectorError::MissingConnectorTransactionID
| errors::ConnectorError::MissingConnectorRefundID
| errors::ConnectorError::MissingApplePayTokenData
| errors::ConnectorError::WebhooksNotImplemented
| errors::ConnectorError::WebhookBodyDecodingFailed
| errors::ConnectorError::WebhookSignatureNotFound
| errors::ConnectorError::WebhookSourceVerificationFailed
| errors::ConnectorError::WebhookVerificationSecretNotFound
| errors::ConnectorError::WebhookVerificationSecretInvalid
| errors::ConnectorError::WebhookReferenceIdNotFound
| errors::ConnectorError::WebhookEventTypeNotFound
| errors::ConnectorError::WebhookResourceObjectNotFound
| errors::ConnectorError::WebhookResponseEncodingFailed
| errors::ConnectorError::InvalidDateFormat
| errors::ConnectorError::DateFormattingFailed
| errors::ConnectorError::InvalidDataFormat { .. }
| errors::ConnectorError::MismatchedPaymentData
| errors::ConnectorError::MandatePaymentDataMismatch { .. }
| errors::ConnectorError::InvalidWalletToken { .. }
| errors::ConnectorError::MissingConnectorRelatedTransactionID { .. }
| errors::ConnectorError::FileValidationFailed { .. }
| errors::ConnectorError::MissingConnectorRedirectionPayload { .. }
| errors::ConnectorError::FailedAtConnector { .. }
| errors::ConnectorError::MissingPaymentMethodType
| errors::ConnectorError::InSufficientBalanceInPaymentMethod
| errors::ConnectorError::RequestTimeoutReceived
| errors::ConnectorError::CurrencyNotSupported { .. }
| errors::ConnectorError::InvalidConnectorConfig { .. }
| errors::ConnectorError::AmountConversionFailed
| errors::ConnectorError::GenericError { .. } => {
err.change_context(errors::ApiErrorResponse::RefundFailed { data: None })
}
})
}
fn to_payment_failed_response(self) -> error_stack::Result<T, errors::ApiErrorResponse> {
self.map_err(|err| {
let error = match err.current_context() {
errors::ConnectorError::ProcessingStepFailed(Some(bytes)) => {
let response_str = std::str::from_utf8(bytes);
let data = match response_str {
Ok(s) => serde_json::from_str(s)
.map_err(
|error| logger::error!(%error,"Failed to convert response to JSON"),
)
.ok(),
Err(error) => {
logger::error!(%error,"Failed to convert response to UTF8 string");
None
}
};
errors::ApiErrorResponse::PaymentAuthorizationFailed { data }
}
errors::ConnectorError::MissingRequiredField { field_name } => {
errors::ApiErrorResponse::MissingRequiredField { field_name }
}
errors::ConnectorError::MissingRequiredFields { field_names } => {
errors::ApiErrorResponse::MissingRequiredFields { field_names: field_names.to_vec() }
}
errors::ConnectorError::NotImplemented(reason) => {
errors::ApiErrorResponse::NotImplemented {
message: errors::NotImplementedMessage::Reason(
reason.to_string(),
),
}
}
errors::ConnectorError::MismatchedPaymentData => {
errors::ApiErrorResponse::InvalidDataValue {
field_name:
"payment_method_data, payment_method_type and payment_experience does not match",
}
},
errors::ConnectorError::MandatePaymentDataMismatch {fields}=> {
errors::ApiErrorResponse::MandatePaymentDataMismatch {
fields: fields.to_owned(),
}
},
errors::ConnectorError::NotSupported { message, connector } => {
errors::ApiErrorResponse::NotSupported { message: format!("{message} is not supported by {connector}") }
},
errors::ConnectorError::FlowNotSupported{ flow, connector } => {
errors::ApiErrorResponse::FlowNotSupported { flow: flow.to_owned(), connector: connector.to_owned() }
},
errors::ConnectorError::MaxFieldLengthViolated{ connector, field_name, max_length, received_length} => {
errors::ApiErrorResponse::MaxFieldLengthViolated { connector: connector.to_string(), field_name: field_name.to_string(), max_length: *max_length, received_length: *received_length }
},
errors::ConnectorError::InvalidDataFormat { field_name } => {
errors::ApiErrorResponse::InvalidDataValue { field_name }
},
errors::ConnectorError::CaptureMethodNotSupported => {
errors::ApiErrorResponse::NotSupported {
message: "Capture Method Not Supported".to_owned(),
}
}
errors::ConnectorError::InvalidWalletToken {wallet_name} => errors::ApiErrorResponse::InvalidWalletToken {wallet_name: wallet_name.to_string()},
errors::ConnectorError::CurrencyNotSupported { message, connector} => errors::ApiErrorResponse::CurrencyNotSupported { message: format!("Credentials for the currency {message} are not configured with the connector {connector}/hyperswitch") },
errors::ConnectorError::FailedToObtainAuthType => errors::ApiErrorResponse::InvalidConnectorConfiguration {config: "connector_account_details".to_string()},
errors::ConnectorError::InvalidConnectorConfig { config } => errors::ApiErrorResponse::InvalidConnectorConfiguration { config: config.to_string() },
errors::ConnectorError::FailedToObtainIntegrationUrl |
errors::ConnectorError::RequestEncodingFailed |
errors::ConnectorError::RequestEncodingFailedWithReason(_) |
errors::ConnectorError::ParsingFailed |
errors::ConnectorError::ResponseDeserializationFailed |
errors::ConnectorError::UnexpectedResponseError(_) |
errors::ConnectorError::RoutingRulesParsingError |
errors::ConnectorError::FailedToObtainPreferredConnector |
errors::ConnectorError::InvalidConnectorName |
errors::ConnectorError::InvalidWallet |
errors::ConnectorError::ResponseHandlingFailed |
errors::ConnectorError::FailedToObtainCertificate |
errors::ConnectorError::NoConnectorMetaData | errors::ConnectorError::NoConnectorWalletDetails |
errors::ConnectorError::FailedToObtainCertificateKey |
errors::ConnectorError::MissingConnectorMandateID |
errors::ConnectorError::MissingConnectorMandateMetadata |
errors::ConnectorError::MissingConnectorTransactionID |
errors::ConnectorError::MissingConnectorRefundID |
errors::ConnectorError::MissingApplePayTokenData |
errors::ConnectorError::WebhooksNotImplemented |
errors::ConnectorError::WebhookBodyDecodingFailed |
errors::ConnectorError::WebhookSignatureNotFound |
errors::ConnectorError::WebhookSourceVerificationFailed |
errors::ConnectorError::WebhookVerificationSecretNotFound |
errors::ConnectorError::WebhookVerificationSecretInvalid |
errors::ConnectorError::WebhookReferenceIdNotFound |
errors::ConnectorError::WebhookEventTypeNotFound |
errors::ConnectorError::WebhookResourceObjectNotFound |
errors::ConnectorError::WebhookResponseEncodingFailed |
errors::ConnectorError::InvalidDateFormat |
errors::ConnectorError::DateFormattingFailed |
errors::ConnectorError::MissingConnectorRelatedTransactionID { .. } |
errors::ConnectorError::FileValidationFailed { .. } |
errors::ConnectorError::MissingConnectorRedirectionPayload { .. } |
errors::ConnectorError::FailedAtConnector { .. } |
errors::ConnectorError::MissingPaymentMethodType |
errors::ConnectorError::InSufficientBalanceInPaymentMethod |
errors::ConnectorError::RequestTimeoutReceived |
errors::ConnectorError::ProcessingStepFailed(None)|
errors::ConnectorError::GenericError {..} |
errors::ConnectorError::AmountConversionFailed => errors::ApiErrorResponse::InternalServerError
};
err.change_context(error)
})
}
fn to_setup_mandate_failed_response(self) -> error_stack::Result<T, errors::ApiErrorResponse> {
self.map_err(|err| {
let error = err.current_context();
let data = match error {
errors::ConnectorError::ProcessingStepFailed(Some(bytes)) => {
let response_str = std::str::from_utf8(bytes);
let error_response = match response_str {
Ok(s) => serde_json::from_str(s)
.map_err(
|err| logger::error!(%err, "Failed to convert response to JSON"),
)
.ok(),
Err(err) => {
logger::error!(%err, "Failed to convert response to UTF8 string");
None
}
};
errors::ApiErrorResponse::PaymentAuthorizationFailed {
data: error_response,
}
}
errors::ConnectorError::MissingRequiredField { field_name } => {
errors::ApiErrorResponse::MissingRequiredField { field_name }
}
errors::ConnectorError::FailedToObtainIntegrationUrl => {
errors::ApiErrorResponse::InvalidConnectorConfiguration {
config: "connector_account_details".to_string(),
}
}
errors::ConnectorError::InvalidConnectorConfig { config: field_name } => {
errors::ApiErrorResponse::InvalidConnectorConfiguration {
config: field_name.to_string(),
}
}
errors::ConnectorError::InvalidWalletToken { wallet_name } => {
errors::ApiErrorResponse::InvalidWalletToken {
wallet_name: wallet_name.to_string(),
}
}
errors::ConnectorError::CaptureMethodNotSupported => {
errors::ApiErrorResponse::NotSupported {
message: "Capture Method Not Supported".to_owned(),
}
}
errors::ConnectorError::RequestEncodingFailed
| errors::ConnectorError::RequestEncodingFailedWithReason(_)
| errors::ConnectorError::ParsingFailed
| errors::ConnectorError::ResponseDeserializationFailed
| errors::ConnectorError::UnexpectedResponseError(_)
| errors::ConnectorError::RoutingRulesParsingError
| errors::ConnectorError::FailedToObtainPreferredConnector
| errors::ConnectorError::InvalidConnectorName
| errors::ConnectorError::InvalidWallet
| errors::ConnectorError::ResponseHandlingFailed
| errors::ConnectorError::MissingRequiredFields { .. }
| errors::ConnectorError::FailedToObtainAuthType
| errors::ConnectorError::FailedToObtainCertificate
| errors::ConnectorError::NoConnectorMetaData
| errors::ConnectorError::NoConnectorWalletDetails
| errors::ConnectorError::FailedToObtainCertificateKey
| errors::ConnectorError::NotImplemented(_)
| errors::ConnectorError::NotSupported { .. }
| errors::ConnectorError::MaxFieldLengthViolated { .. }
| errors::ConnectorError::FlowNotSupported { .. }
| errors::ConnectorError::MissingConnectorMandateID
| errors::ConnectorError::MissingConnectorMandateMetadata
| errors::ConnectorError::MissingConnectorTransactionID
| errors::ConnectorError::MissingConnectorRefundID
| errors::ConnectorError::MissingApplePayTokenData
| errors::ConnectorError::WebhooksNotImplemented
| errors::ConnectorError::WebhookBodyDecodingFailed
| errors::ConnectorError::WebhookSignatureNotFound
| errors::ConnectorError::WebhookSourceVerificationFailed
| errors::ConnectorError::WebhookVerificationSecretNotFound
| errors::ConnectorError::WebhookVerificationSecretInvalid
| errors::ConnectorError::WebhookReferenceIdNotFound
| errors::ConnectorError::WebhookEventTypeNotFound
| errors::ConnectorError::WebhookResourceObjectNotFound
| errors::ConnectorError::WebhookResponseEncodingFailed
| errors::ConnectorError::InvalidDateFormat
| errors::ConnectorError::DateFormattingFailed
| errors::ConnectorError::InvalidDataFormat { .. }
| errors::ConnectorError::MismatchedPaymentData
| errors::ConnectorError::MandatePaymentDataMismatch { .. }
| errors::ConnectorError::MissingConnectorRelatedTransactionID { .. }
| errors::ConnectorError::FileValidationFailed { .. }
| errors::ConnectorError::MissingConnectorRedirectionPayload { .. }
| errors::ConnectorError::FailedAtConnector { .. }
| errors::ConnectorError::MissingPaymentMethodType
| errors::ConnectorError::InSufficientBalanceInPaymentMethod
| errors::ConnectorError::RequestTimeoutReceived
| errors::ConnectorError::CurrencyNotSupported { .. }
| errors::ConnectorError::ProcessingStepFailed(None)
| errors::ConnectorError::AmountConversionFailed
| errors::ConnectorError::GenericError { .. } => {
logger::error!(%error,"Setup Mandate flow failed");
errors::ApiErrorResponse::PaymentAuthorizationFailed { data: None }
}
};
err.change_context(data)
})
}
fn to_dispute_failed_response(self) -> error_stack::Result<T, errors::ApiErrorResponse> {
self.map_err(|err| {
let error = match err.current_context() {
errors::ConnectorError::ProcessingStepFailed(Some(bytes)) => {
let response_str = std::str::from_utf8(bytes);
let data = match response_str {
Ok(s) => serde_json::from_str(s)
.map_err(
|error| logger::error!(%error,"Failed to convert response to JSON"),
)
.ok(),
Err(error) => {
logger::error!(%error,"Failed to convert response to UTF8 string");
None
}
};
errors::ApiErrorResponse::DisputeFailed { data }
}
errors::ConnectorError::MissingRequiredField { field_name } => {
errors::ApiErrorResponse::MissingRequiredField { field_name }
}
errors::ConnectorError::MissingRequiredFields { field_names } => {
errors::ApiErrorResponse::MissingRequiredFields {
field_names: field_names.to_vec(),
}
}
_ => errors::ApiErrorResponse::InternalServerError,
};
err.change_context(error)
})
}
fn to_files_failed_response(self) -> error_stack::Result<T, errors::ApiErrorResponse> {
self.map_err(|err| {
let error = match err.current_context() {
errors::ConnectorError::ProcessingStepFailed(Some(bytes)) => {
let response_str = std::str::from_utf8(bytes);
let data = match response_str {
Ok(s) => serde_json::from_str(s)
.map_err(
|error| logger::error!(%error,"Failed to convert response to JSON"),
)
.ok(),
Err(error) => {
logger::error!(%error,"Failed to convert response to UTF8 string");
None
}
};
errors::ApiErrorResponse::DisputeFailed { data }
}
errors::ConnectorError::MissingRequiredField { field_name } => {
errors::ApiErrorResponse::MissingRequiredField { field_name }
}
errors::ConnectorError::MissingRequiredFields { field_names } => {
errors::ApiErrorResponse::MissingRequiredFields {
field_names: field_names.to_vec(),
}
}
_ => errors::ApiErrorResponse::InternalServerError,
};
err.change_context(error)
})
}
#[cfg(feature = "payouts")]
fn to_payout_failed_response(self) -> error_stack::Result<T, errors::ApiErrorResponse> {
self.map_err(|err| {
let error = match err.current_context() {
errors::ConnectorError::ProcessingStepFailed(Some(bytes)) => {
let response_str = std::str::from_utf8(bytes);
let data = match response_str {
Ok(s) => serde_json::from_str(s)
.map_err(
|error| logger::error!(%error,"Failed to convert response to JSON"),
)
.ok(),
Err(error) => {
logger::error!(%error,"Failed to convert response to UTF8 string");
None
}
};
errors::ApiErrorResponse::PayoutFailed { data }
}
errors::ConnectorError::MissingRequiredField { field_name } => {
errors::ApiErrorResponse::MissingRequiredField { field_name }
}
errors::ConnectorError::MissingRequiredFields { field_names } => {
errors::ApiErrorResponse::MissingRequiredFields {
field_names: field_names.to_vec(),
}
}
errors::ConnectorError::NotSupported { message, connector } => {
errors::ApiErrorResponse::NotSupported {
message: format!("{message} by {connector}"),
}
}
errors::ConnectorError::NotImplemented(reason) => {
errors::ApiErrorResponse::NotImplemented {
message: errors::NotImplementedMessage::Reason(reason.to_string()),
}
}
errors::ConnectorError::InvalidConnectorConfig { config } => {
errors::ApiErrorResponse::InvalidConnectorConfiguration {
config: config.to_string(),
}
}
_ => errors::ApiErrorResponse::InternalServerError,
};
err.change_context(error)
})
}
fn to_vault_failed_response(self) -> error_stack::Result<T, errors::ApiErrorResponse> {
self.map_err(|err| {
let error = match err.current_context() {
errors::ConnectorError::ProcessingStepFailed(_) => {
errors::ApiErrorResponse::ExternalVaultFailed
}
errors::ConnectorError::MissingRequiredField { field_name } => {
errors::ApiErrorResponse::MissingRequiredField { field_name }
}
errors::ConnectorError::MissingRequiredFields { field_names } => {
errors::ApiErrorResponse::MissingRequiredFields {
field_names: field_names.to_vec(),
}
}
errors::ConnectorError::NotSupported { message, connector } => {
errors::ApiErrorResponse::NotSupported {
message: format!("{message} by {connector}"),
}
}
errors::ConnectorError::NotImplemented(reason) => {
errors::ApiErrorResponse::NotImplemented {
message: errors::NotImplementedMessage::Reason(reason.to_string()),
}
}
errors::ConnectorError::InvalidConnectorConfig { config } => {
errors::ApiErrorResponse::InvalidConnectorConfiguration {
config: config.to_string(),
}
}
_ => errors::ApiErrorResponse::InternalServerError,
};
err.change_context(error)
})
}
fn allow_webhook_event_type_not_found(
self,
enabled: bool,
) -> CustomResult<Option<T>, errors::ConnectorError> {
match self {
Ok(event_type) => Ok(Some(event_type)),
Err(error) => match error.current_context() {
errors::ConnectorError::WebhookEventTypeNotFound if enabled => Ok(None),
_ => Err(error),
},
}
}
}
pub trait RedisErrorExt {
#[track_caller]
fn to_redis_failed_response(self, key: &str) -> error_stack::Report<errors::StorageError>;
}
impl RedisErrorExt for error_stack::Report<errors::RedisError> {
fn to_redis_failed_response(self, key: &str) -> error_stack::Report<errors::StorageError> {
match self.current_context() {
errors::RedisError::NotFound => self.change_context(
errors::StorageError::ValueNotFound(format!("Data does not exist for key {key}")),
),
errors::RedisError::SetNxFailed => {
self.change_context(errors::StorageError::DuplicateValue {
entity: "redis",
key: Some(key.to_string()),
})
}
_ => self.change_context(errors::StorageError::KVError),
}
}
}
#[cfg(feature = "olap")]
impl<T> StorageErrorExt<T, errors::UserErrors> for error_stack::Result<T, errors::StorageError> {
#[track_caller]
fn to_not_found_response(
self,
not_found_response: errors::UserErrors,
) -> error_stack::Result<T, errors::UserErrors> {
self.map_err(|e| {
if e.current_context().is_db_not_found() {
e.change_context(not_found_response)
} else {
e.change_context(errors::UserErrors::InternalServerError)
}
})
}
#[track_caller]
fn to_duplicate_response(
self,
duplicate_response: errors::UserErrors,
) -> error_stack::Result<T, errors::UserErrors> {
self.map_err(|e| {
if e.current_context().is_db_unique_violation() {
e.change_context(duplicate_response)
} else {
e.change_context(errors::UserErrors::InternalServerError)
}
})
}
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/errors/chat.rs | crates/router/src/core/errors/chat.rs | #[derive(Debug, thiserror::Error)]
pub enum ChatErrors {
#[error("User InternalServerError")]
InternalServerError,
#[error("Missing Config error")]
MissingConfigError,
#[error("Chat response deserialization failed")]
ChatResponseDeserializationFailed,
#[error("Unauthorized access")]
UnauthorizedAccess,
}
impl common_utils::errors::ErrorSwitch<api_models::errors::types::ApiErrorResponse> for ChatErrors {
fn switch(&self) -> api_models::errors::types::ApiErrorResponse {
use api_models::errors::types::{ApiError, ApiErrorResponse as AER};
let sub_code = "AI";
match self {
Self::InternalServerError => {
AER::InternalServerError(ApiError::new("HE", 0, self.get_error_message(), None))
}
Self::MissingConfigError => {
AER::InternalServerError(ApiError::new(sub_code, 1, self.get_error_message(), None))
}
Self::ChatResponseDeserializationFailed => {
AER::BadRequest(ApiError::new(sub_code, 2, self.get_error_message(), None))
}
Self::UnauthorizedAccess => {
AER::Unauthorized(ApiError::new(sub_code, 3, self.get_error_message(), None))
}
}
}
}
impl ChatErrors {
pub fn get_error_message(&self) -> String {
match self {
Self::InternalServerError => "Something went wrong".to_string(),
Self::MissingConfigError => "Missing webhook url".to_string(),
Self::ChatResponseDeserializationFailed => "Failed to parse chat response".to_string(),
Self::UnauthorizedAccess => "Not authorized to access the resource".to_string(),
}
}
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/errors/transformers.rs | crates/router/src/core/errors/transformers.rs | use common_utils::errors::ErrorSwitch;
use hyperswitch_domain_models::errors::api_error_response::ApiErrorResponse;
use super::{CustomersErrorResponse, StorageError};
impl ErrorSwitch<api_models::errors::types::ApiErrorResponse> for CustomersErrorResponse {
fn switch(&self) -> api_models::errors::types::ApiErrorResponse {
use api_models::errors::types::{ApiError, ApiErrorResponse as AER};
match self {
Self::CustomerRedacted => AER::BadRequest(ApiError::new(
"IR",
11,
"Customer has already been redacted",
None,
)),
Self::InternalServerError => {
AER::InternalServerError(ApiError::new("HE", 0, "Something went wrong", None))
}
Self::InvalidRequestData { message } => AER::BadRequest(ApiError::new(
"IR",
7,
format!("Invalid value provided:{}", message),
None,
)),
Self::MandateActive => AER::BadRequest(ApiError::new(
"IR",
10,
"Customer has active mandate/subsciption",
None,
)),
Self::CustomerNotFound => AER::NotFound(ApiError::new(
"HE",
2,
"Customer does not exist in our records",
None,
)),
Self::CustomerAlreadyExists => AER::BadRequest(ApiError::new(
"IR",
12,
"Customer with the given `customer_id` already exists",
None,
)),
}
}
}
impl ErrorSwitch<CustomersErrorResponse> for StorageError {
fn switch(&self) -> CustomersErrorResponse {
use CustomersErrorResponse as CER;
match self {
err if err.is_db_not_found() => CER::CustomerNotFound,
Self::CustomerRedacted => CER::CustomerRedacted,
_ => CER::InternalServerError,
}
}
}
impl ErrorSwitch<CustomersErrorResponse> for common_utils::errors::CryptoError {
fn switch(&self) -> CustomersErrorResponse {
CustomersErrorResponse::InternalServerError
}
}
impl ErrorSwitch<CustomersErrorResponse> for ApiErrorResponse {
fn switch(&self) -> CustomersErrorResponse {
use CustomersErrorResponse as CER;
match self {
Self::InternalServerError => CER::InternalServerError,
Self::MandateActive => CER::MandateActive,
Self::CustomerNotFound => CER::CustomerNotFound,
_ => CER::InternalServerError,
}
}
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/errors/customers_error_response.rs | crates/router/src/core/errors/customers_error_response.rs | use http::StatusCode;
#[derive(Debug, thiserror::Error)]
pub enum CustomersErrorResponse {
#[error("Customer has already been redacted")]
CustomerRedacted,
#[error("Something went wrong")]
InternalServerError,
#[error("Invalid request data: {message}")]
InvalidRequestData { message: String },
#[error("Customer has already been redacted")]
MandateActive,
#[error("Customer does not exist in our records")]
CustomerNotFound,
#[error("Customer with the given customer id already exists")]
CustomerAlreadyExists,
}
impl actix_web::ResponseError for CustomersErrorResponse {
fn status_code(&self) -> StatusCode {
common_utils::errors::ErrorSwitch::<api_models::errors::types::ApiErrorResponse>::switch(
self,
)
.status_code()
}
fn error_response(&self) -> actix_web::HttpResponse {
common_utils::errors::ErrorSwitch::<api_models::errors::types::ApiErrorResponse>::switch(
self,
)
.error_response()
}
}
// should be removed hola bola
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/errors/user/sample_data.rs | crates/router/src/core/errors/user/sample_data.rs | use api_models::errors::types::{ApiError, ApiErrorResponse};
use common_utils::errors::{CustomResult, ErrorSwitch, ErrorSwitchFrom};
use storage_impl::errors::StorageError;
pub type SampleDataResult<T> = CustomResult<T, SampleDataError>;
#[derive(Debug, Clone, serde::Serialize, thiserror::Error)]
pub enum SampleDataError {
#[error["Internal Server Error"]]
InternalServerError,
#[error("Data Does Not Exist")]
DataDoesNotExist,
#[error("Invalid Parameters")]
InvalidParameters,
#[error["Invalid Records"]]
InvalidRange,
}
impl ErrorSwitch<ApiErrorResponse> for SampleDataError {
fn switch(&self) -> ApiErrorResponse {
match self {
Self::InternalServerError => ApiErrorResponse::InternalServerError(ApiError::new(
"SD",
0,
"Something went wrong",
None,
)),
Self::DataDoesNotExist => ApiErrorResponse::NotFound(ApiError::new(
"SD",
1,
"Sample Data not present for given request",
None,
)),
Self::InvalidParameters => ApiErrorResponse::BadRequest(ApiError::new(
"SD",
2,
"Invalid parameters to generate Sample Data",
None,
)),
Self::InvalidRange => ApiErrorResponse::BadRequest(ApiError::new(
"SD",
3,
"Records to be generated should be between range 10 and 100",
None,
)),
}
}
}
impl ErrorSwitchFrom<StorageError> for SampleDataError {
fn switch_from(error: &StorageError) -> Self {
match matches!(error, StorageError::ValueNotFound(_)) {
true => Self::DataDoesNotExist,
false => Self::InternalServerError,
}
}
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/authentication/types.rs | crates/router/src/core/authentication/types.rs | use error_stack::{Report, ResultExt};
pub use hyperswitch_domain_models::{
authentication,
router_request_types::authentication::{
AcquirerDetails, ExternalThreeDSConnectorMetadata, PreAuthenticationData, ThreeDsMethodData,
},
};
use crate::{core::errors, types::transformers::ForeignTryFrom, utils::OptionExt};
impl ForeignTryFrom<&authentication::Authentication> for PreAuthenticationData {
type Error = Report<errors::ApiErrorResponse>;
fn foreign_try_from(
authentication: &authentication::Authentication,
) -> Result<Self, Self::Error> {
let error_message = errors::ApiErrorResponse::UnprocessableEntity { message: "Pre Authentication must be completed successfully before Authentication can be performed".to_string() };
let threeds_server_transaction_id = authentication
.threeds_server_transaction_id
.clone()
.get_required_value("threeds_server_transaction_id")
.change_context(error_message)?;
let message_version = authentication
.message_version
.clone()
.get_required_value("message_version")?;
Ok(Self {
threeds_server_transaction_id,
message_version,
acquirer_bin: authentication.acquirer_bin.clone(),
acquirer_merchant_id: authentication.acquirer_merchant_id.clone(),
acquirer_country_code: authentication.acquirer_country_code.clone(),
connector_metadata: authentication.connector_metadata.clone(),
})
}
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/authentication/utils.rs | crates/router/src/core/authentication/utils.rs | use common_utils::{ext_traits::AsyncExt, types::keymanager::ToEncryptable};
use error_stack::ResultExt;
use hyperswitch_domain_models::{
authentication, router_data_v2::ExternalAuthenticationFlowData, router_request_types,
type_encryption::AsyncLift,
};
use masking::{ExposeInterface, PeekInterface};
use crate::{
consts,
core::{
errors::{self, ConnectorErrorExt, StorageErrorExt},
payments,
},
errors::RouterResult,
routes::SessionState,
services::{self, execute_connector_processing_step},
types::{
api, authentication::AuthenticationResponseData, domain, transformers::ForeignFrom,
RouterData,
},
utils::OptionExt,
};
#[cfg(feature = "v1")]
pub fn get_connector_data_if_separate_authn_supported(
connector_call_type: &api::ConnectorCallType,
) -> Option<api::ConnectorData> {
match connector_call_type {
api::ConnectorCallType::PreDetermined(connector_routing_data) => {
if connector_routing_data
.connector_data
.connector_name
.is_separate_authentication_supported()
{
Some(connector_routing_data.connector_data.clone())
} else {
None
}
}
api::ConnectorCallType::Retryable(connector_routing_data) => connector_routing_data
.first()
.and_then(|connector_routing_data| {
if connector_routing_data
.connector_data
.connector_name
.is_separate_authentication_supported()
{
Some(connector_routing_data.connector_data.clone())
} else {
None
}
}),
api::ConnectorCallType::SessionMultiple(_) => None,
}
}
#[allow(clippy::too_many_arguments)]
pub async fn update_trackers<F: Clone, Req>(
state: &SessionState,
router_data: RouterData<F, Req, AuthenticationResponseData>,
authentication: authentication::Authentication,
acquirer_details: Option<super::types::AcquirerDetails>,
merchant_key_store: &hyperswitch_domain_models::merchant_key_store::MerchantKeyStore,
authentication_info: router_request_types::authentication::AuthenticationInfo,
) -> RouterResult<authentication::Authentication> {
let key_manager_state = state.into();
let authentication_update = match router_data.response {
Ok(response) => match response {
AuthenticationResponseData::PreAuthNResponse {
threeds_server_transaction_id,
maximum_supported_3ds_version,
connector_authentication_id,
three_ds_method_data,
three_ds_method_url,
message_version,
connector_metadata,
directory_server_id,
scheme_id,
} => {
let billing_details_encoded = authentication_info
.billing_address
.clone()
.map(|billing| {
common_utils::ext_traits::Encode::encode_to_value(&billing)
.map(masking::Secret::<serde_json::Value>::new)
})
.transpose()
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Unable to encode billing details to serde_json::Value")?;
let shipping_details_encoded = authentication_info
.shipping_address
.clone()
.map(|shipping| {
common_utils::ext_traits::Encode::encode_to_value(&shipping)
.map(masking::Secret::<serde_json::Value>::new)
})
.transpose()
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Unable to encode shipping details to serde_json::Value")?;
let encrypted_data = domain::types::crypto_operation(
&key_manager_state,
common_utils::type_name!(authentication::Authentication),
domain::types::CryptoOperation::BatchEncrypt(
authentication::UpdateEncryptableAuthentication::to_encryptable(
authentication::UpdateEncryptableAuthentication {
billing_address: billing_details_encoded,
shipping_address: shipping_details_encoded,
},
),
),
common_utils::types::keymanager::Identifier::Merchant(
merchant_key_store.merchant_id.clone(),
),
merchant_key_store.key.peek(),
)
.await
.and_then(|val| val.try_into_batchoperation())
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Unable to encrypt authentication data".to_string())?;
let browser_info = authentication_info
.browser_info
.as_ref()
.map(common_utils::ext_traits::Encode::encode_to_value)
.transpose()
.change_context(errors::ApiErrorResponse::InvalidDataValue {
field_name: "browser_information",
})?;
let encrypted_data =
authentication::FromRequestEncryptableAuthentication::from_encryptable(
encrypted_data,
)
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable(
"Unable to get encrypted data for authentication after encryption",
)?;
let email_encrypted = authentication_info
.email
.clone()
.async_lift(|inner| async {
domain::types::crypto_operation(
&key_manager_state,
common_utils::type_name!(authentication::Authentication),
domain::types::CryptoOperation::EncryptOptional(
inner.map(|inner| inner.expose()),
),
common_utils::types::keymanager::Identifier::Merchant(
merchant_key_store.merchant_id.clone(),
),
merchant_key_store.key.peek(),
)
.await
.and_then(|val| val.try_into_optionaloperation())
})
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Unable to encrypt email")?;
authentication::AuthenticationUpdate::PreAuthenticationUpdate {
threeds_server_transaction_id,
maximum_supported_3ds_version: maximum_supported_3ds_version.clone(),
connector_authentication_id,
three_ds_method_data,
three_ds_method_url,
message_version,
connector_metadata,
authentication_status: common_enums::AuthenticationStatus::Pending,
acquirer_bin: acquirer_details
.as_ref()
.map(|acquirer_details| acquirer_details.acquirer_bin.clone()),
acquirer_merchant_id: acquirer_details
.as_ref()
.map(|acquirer_details| acquirer_details.acquirer_merchant_id.clone()),
acquirer_country_code: acquirer_details
.and_then(|acquirer_details| acquirer_details.acquirer_country_code),
directory_server_id,
billing_address: Box::new(encrypted_data.billing_address),
shipping_address: Box::new(encrypted_data.shipping_address),
browser_info: Box::new(browser_info),
email: email_encrypted,
scheme_id,
merchant_category_code: authentication_info.merchant_category_code,
merchant_country_code: authentication_info
.merchant_country_code
.map(|merchant_country_code| merchant_country_code.to_string()),
billing_country: authentication_info.billing_address.and_then(
|billing_address| {
billing_address.address.and_then(|address| {
address.country.map(|country| country.to_string())
})
},
),
shipping_country: authentication_info.shipping_address.and_then(
|shipping_address| {
shipping_address.address.and_then(|address| {
address.country.map(|country| country.to_string())
})
},
),
earliest_supported_version: Some(maximum_supported_3ds_version.clone()),
latest_supported_version: Some(maximum_supported_3ds_version.clone()),
}
}
AuthenticationResponseData::AuthNResponse {
authn_flow_type,
authentication_value,
trans_status,
connector_metadata,
ds_trans_id,
eci,
challenge_code,
challenge_cancel,
challenge_code_reason,
message_extension,
} => {
authentication_value
.async_map(|auth_val| {
crate::core::payment_methods::vault::create_tokenize(
state,
auth_val.expose(),
None,
authentication
.authentication_id
.get_string_repr()
.to_string(),
merchant_key_store.key.get_inner(),
)
})
.await
.transpose()?;
let authentication_status =
common_enums::AuthenticationStatus::foreign_from(trans_status.clone());
authentication::AuthenticationUpdate::AuthenticationUpdate {
trans_status,
acs_url: authn_flow_type.get_acs_url(),
challenge_request: authn_flow_type.get_challenge_request(),
challenge_request_key: authn_flow_type.get_challenge_request_key(),
acs_reference_number: authn_flow_type.get_acs_reference_number(),
acs_trans_id: authn_flow_type.get_acs_trans_id(),
acs_signed_content: authn_flow_type.get_acs_signed_content(),
authentication_type: authn_flow_type.get_decoupled_authentication_type(),
authentication_status,
connector_metadata,
ds_trans_id,
eci,
challenge_code,
challenge_cancel,
challenge_code_reason,
message_extension,
device_type: authentication_info
.device_details
.as_ref()
.and_then(|device_details| device_details.device_type.clone()),
device_brand: authentication_info
.device_details
.as_ref()
.and_then(|device_details| device_details.device_brand.clone()),
device_os: authentication_info
.device_details
.as_ref()
.and_then(|device_details| device_details.device_os.clone()),
device_display: authentication_info
.device_details
.as_ref()
.and_then(|device_details| device_details.device_display.clone()),
}
}
AuthenticationResponseData::PostAuthNResponse {
trans_status,
authentication_value,
eci,
challenge_cancel,
challenge_code_reason,
} => {
authentication_value
.async_map(|auth_val| {
crate::core::payment_methods::vault::create_tokenize(
state,
auth_val.expose(),
None,
authentication
.authentication_id
.get_string_repr()
.to_string(),
merchant_key_store.key.get_inner(),
)
})
.await
.transpose()?;
authentication::AuthenticationUpdate::PostAuthenticationUpdate {
authentication_status: common_enums::AuthenticationStatus::foreign_from(
trans_status.clone(),
),
trans_status,
eci,
challenge_cancel,
challenge_code_reason,
}
}
AuthenticationResponseData::PreAuthVersionCallResponse {
maximum_supported_3ds_version,
} => authentication::AuthenticationUpdate::PreAuthenticationVersionCallUpdate {
message_version: maximum_supported_3ds_version.clone(),
maximum_supported_3ds_version,
},
AuthenticationResponseData::PreAuthThreeDsMethodCallResponse {
threeds_server_transaction_id,
three_ds_method_data,
three_ds_method_url,
connector_metadata,
} => authentication::AuthenticationUpdate::PreAuthenticationThreeDsMethodCall {
threeds_server_transaction_id,
three_ds_method_data,
three_ds_method_url,
connector_metadata,
acquirer_bin: acquirer_details
.as_ref()
.map(|acquirer_details| acquirer_details.acquirer_bin.clone()),
acquirer_merchant_id: acquirer_details
.map(|acquirer_details| acquirer_details.acquirer_merchant_id),
},
},
Err(error) => authentication::AuthenticationUpdate::ErrorUpdate {
connector_authentication_id: error.connector_transaction_id,
authentication_status: common_enums::AuthenticationStatus::Failed,
error_message: error
.reason
.map(|reason| format!("message: {}, reason: {}", error.message, reason))
.or(Some(error.message)),
error_code: Some(error.code),
},
};
state
.store
.update_authentication_by_merchant_id_authentication_id(
authentication,
authentication_update,
merchant_key_store,
&key_manager_state,
)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Error while updating authentication")
}
impl ForeignFrom<common_enums::AuthenticationStatus> for common_enums::AttemptStatus {
fn foreign_from(from: common_enums::AuthenticationStatus) -> Self {
match from {
common_enums::AuthenticationStatus::Started
| common_enums::AuthenticationStatus::Pending => Self::AuthenticationPending,
common_enums::AuthenticationStatus::Success => Self::AuthenticationSuccessful,
common_enums::AuthenticationStatus::Failed => Self::AuthenticationFailed,
}
}
}
#[allow(clippy::too_many_arguments)]
pub async fn create_new_authentication(
state: &SessionState,
merchant_id: common_utils::id_type::MerchantId,
authentication_connector: String,
token: String,
profile_id: common_utils::id_type::ProfileId,
payment_id: common_utils::id_type::PaymentId,
merchant_connector_id: common_utils::id_type::MerchantConnectorAccountId,
organization_id: common_utils::id_type::OrganizationId,
force_3ds_challenge: Option<bool>,
psd2_sca_exemption_type: Option<common_enums::ScaExemptionType>,
merchant_key_store: &domain::MerchantKeyStore,
) -> RouterResult<authentication::Authentication> {
let authentication_id = common_utils::id_type::AuthenticationId::generate_authentication_id(
consts::AUTHENTICATION_ID_PREFIX,
);
let authentication_client_secret = Some(common_utils::generate_id_with_default_len(&format!(
"{}_secret",
authentication_id.get_string_repr()
)));
let key_manager_state = (state).into();
let current_time = common_utils::date_time::now();
let new_authentication = authentication::Authentication {
authentication_id: authentication_id.clone(),
merchant_id,
authentication_connector: Some(authentication_connector),
connector_authentication_id: None,
authentication_data: None,
payment_method_id: format!("eph_{token}"),
authentication_type: None,
authentication_status: common_enums::AuthenticationStatus::Started,
authentication_lifecycle_status: common_enums::AuthenticationLifecycleStatus::Unused,
created_at: current_time,
modified_at: current_time,
error_message: None,
error_code: None,
connector_metadata: None,
maximum_supported_version: None,
threeds_server_transaction_id: None,
cavv: None,
authentication_flow_type: None,
message_version: None,
eci: None,
trans_status: None,
acquirer_bin: None,
acquirer_merchant_id: None,
three_ds_method_data: None,
three_ds_method_url: None,
acs_url: None,
challenge_request: None,
acs_reference_number: None,
acs_trans_id: None,
acs_signed_content: None,
profile_id,
payment_id: Some(payment_id),
merchant_connector_id: Some(merchant_connector_id),
ds_trans_id: None,
directory_server_id: None,
acquirer_country_code: None,
organization_id,
mcc: None,
amount: None,
currency: None,
billing_country: None,
shipping_country: None,
issuer_country: None,
earliest_supported_version: None,
latest_supported_version: None,
platform: None,
device_type: None,
device_brand: None,
device_os: None,
device_display: None,
browser_name: None,
browser_version: None,
issuer_id: None,
scheme_name: None,
exemption_requested: None,
exemption_accepted: None,
service_details: None,
authentication_client_secret,
force_3ds_challenge,
psd2_sca_exemption_type,
return_url: None,
billing_address: None,
shipping_address: None,
browser_info: None,
email: None,
profile_acquirer_id: None,
challenge_code: None,
challenge_cancel: None,
challenge_code_reason: None,
message_extension: None,
challenge_request_key: None,
customer_details: None,
merchant_country_code: None,
};
state
.store
.insert_authentication(&key_manager_state, merchant_key_store, new_authentication)
.await
.to_duplicate_response(errors::ApiErrorResponse::GenericDuplicateError {
message: format!(
"Authentication with authentication_id {} already exists",
authentication_id.get_string_repr()
),
})
}
pub async fn do_auth_connector_call<F, Req, Res>(
state: &SessionState,
authentication_connector_name: String,
router_data: RouterData<F, Req, Res>,
) -> RouterResult<RouterData<F, Req, Res>>
where
Req: std::fmt::Debug + Clone + 'static,
Res: std::fmt::Debug + Clone + 'static,
F: std::fmt::Debug + Clone + 'static,
dyn api::Connector + Sync: services::api::ConnectorIntegration<F, Req, Res>,
dyn api::ConnectorV2 + Sync:
services::api::ConnectorIntegrationV2<F, ExternalAuthenticationFlowData, Req, Res>,
{
let connector_data =
api::AuthenticationConnectorData::get_connector_by_name(&authentication_connector_name)?;
let connector_integration: services::BoxedExternalAuthenticationConnectorIntegrationInterface<
F,
Req,
Res,
> = connector_data.connector.get_connector_integration();
let router_data = execute_connector_processing_step(
state,
connector_integration,
&router_data,
payments::CallConnectorAction::Trigger,
None,
None,
)
.await
.to_payment_failed_response()?;
Ok(router_data)
}
pub async fn get_authentication_connector_data(
state: &SessionState,
key_store: &domain::MerchantKeyStore,
business_profile: &domain::Profile,
authentication_connector: Option<String>,
) -> RouterResult<(
common_enums::AuthenticationConnectors,
payments::helpers::MerchantConnectorAccountType,
)> {
let authentication_connector = if let Some(authentication_connector) = authentication_connector
{
api_models::enums::convert_authentication_connector(&authentication_connector).ok_or(
errors::ApiErrorResponse::UnprocessableEntity {
message: format!(
"Invalid authentication_connector found in request : {authentication_connector}",
),
},
)?
} else {
let authentication_details = business_profile
.authentication_connector_details
.clone()
.get_required_value("authentication_details")
.change_context(errors::ApiErrorResponse::UnprocessableEntity {
message: "authentication_connector_details is not available in business profile"
.into(),
})
.attach_printable("authentication_connector_details not configured by the merchant")?;
authentication_details
.authentication_connectors
.first()
.ok_or(errors::ApiErrorResponse::UnprocessableEntity {
message: format!(
"No authentication_connector found for profile_id {:?}",
business_profile.get_id()
),
})
.attach_printable(
"No authentication_connector found from merchant_account.authentication_details",
)?
.to_owned()
};
let profile_id = business_profile.get_id();
let authentication_connector_mca = payments::helpers::get_merchant_connector_account(
state,
&business_profile.merchant_id,
None,
key_store,
profile_id,
authentication_connector.to_string().as_str(),
None,
)
.await?;
Ok((authentication_connector, authentication_connector_mca))
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/authentication/transformers.rs | crates/router/src/core/authentication/transformers.rs | use std::marker::PhantomData;
use api_models::payments;
use common_enums::PaymentMethod;
use common_utils::ext_traits::ValueExt;
use error_stack::ResultExt;
use hyperswitch_domain_models::authentication;
use crate::{
core::{
errors::{self, RouterResult},
payments::helpers as payments_helpers,
},
types::{
self, domain,
transformers::{ForeignFrom, ForeignTryFrom},
},
utils::ext_traits::OptionExt,
SessionState,
};
const IRRELEVANT_ATTEMPT_ID_IN_AUTHENTICATION_FLOW: &str =
"irrelevant_attempt_id_in_AUTHENTICATION_flow";
const IRRELEVANT_CONNECTOR_REQUEST_REFERENCE_ID_IN_AUTHENTICATION_FLOW: &str =
"irrelevant_connector_request_reference_id_in_AUTHENTICATION_flow";
#[allow(clippy::too_many_arguments)]
pub fn construct_authentication_router_data(
state: &SessionState,
merchant_id: common_utils::id_type::MerchantId,
authentication_connector: String,
payment_method_data: domain::PaymentMethodData,
payment_method: PaymentMethod,
billing_address: hyperswitch_domain_models::address::Address,
shipping_address: Option<hyperswitch_domain_models::address::Address>,
browser_details: Option<types::BrowserInformation>,
amount: Option<common_utils::types::MinorUnit>,
currency: Option<common_enums::Currency>,
message_category: types::api::authentication::MessageCategory,
device_channel: payments::DeviceChannel,
merchant_connector_account: payments_helpers::MerchantConnectorAccountType,
authentication_data: authentication::Authentication,
return_url: Option<String>,
sdk_information: Option<payments::SdkInformation>,
threeds_method_comp_ind: payments::ThreeDsCompletionIndicator,
email: Option<common_utils::pii::Email>,
webhook_url: String,
three_ds_requestor_url: String,
psd2_sca_exemption_type: Option<common_enums::ScaExemptionType>,
payment_id: common_utils::id_type::PaymentId,
force_3ds_challenge: bool,
) -> RouterResult<types::authentication::ConnectorAuthenticationRouterData> {
let router_request = types::authentication::ConnectorAuthenticationRequestData {
payment_method_data,
billing_address,
shipping_address,
browser_details,
amount: amount.map(|amt| amt.get_amount_as_i64()),
currency,
message_category,
device_channel,
pre_authentication_data: super::types::PreAuthenticationData::foreign_try_from(
&authentication_data,
)?,
return_url,
sdk_information,
email,
three_ds_requestor_url,
threeds_method_comp_ind,
webhook_url,
force_3ds_challenge,
};
construct_router_data(
state,
authentication_connector,
payment_method,
merchant_id.clone(),
types::PaymentAddress::default(),
router_request,
&merchant_connector_account,
psd2_sca_exemption_type,
payment_id,
)
}
pub fn construct_post_authentication_router_data(
state: &SessionState,
authentication_connector: String,
business_profile: domain::Profile,
merchant_connector_account: payments_helpers::MerchantConnectorAccountType,
authentication_data: &authentication::Authentication,
payment_id: &common_utils::id_type::PaymentId,
) -> RouterResult<types::authentication::ConnectorPostAuthenticationRouterData> {
let threeds_server_transaction_id = authentication_data
.threeds_server_transaction_id
.clone()
.get_required_value("threeds_server_transaction_id")
.change_context(errors::ApiErrorResponse::InternalServerError)?;
let router_request = types::authentication::ConnectorPostAuthenticationRequestData {
threeds_server_transaction_id,
};
construct_router_data(
state,
authentication_connector,
PaymentMethod::default(),
business_profile.merchant_id.clone(),
types::PaymentAddress::default(),
router_request,
&merchant_connector_account,
None,
payment_id.clone(),
)
}
pub fn construct_pre_authentication_router_data<F: Clone>(
state: &SessionState,
authentication_connector: String,
card: hyperswitch_domain_models::payment_method_data::Card,
merchant_connector_account: &payments_helpers::MerchantConnectorAccountType,
merchant_id: common_utils::id_type::MerchantId,
payment_id: common_utils::id_type::PaymentId,
) -> RouterResult<
types::RouterData<
F,
types::authentication::PreAuthNRequestData,
types::authentication::AuthenticationResponseData,
>,
> {
let router_request = types::authentication::PreAuthNRequestData { card };
construct_router_data(
state,
authentication_connector,
PaymentMethod::default(),
merchant_id,
types::PaymentAddress::default(),
router_request,
merchant_connector_account,
None,
payment_id,
)
}
#[allow(clippy::too_many_arguments)]
pub fn construct_router_data<F: Clone, Req, Res>(
state: &SessionState,
authentication_connector_name: String,
payment_method: PaymentMethod,
merchant_id: common_utils::id_type::MerchantId,
address: types::PaymentAddress,
request_data: Req,
merchant_connector_account: &payments_helpers::MerchantConnectorAccountType,
psd2_sca_exemption_type: Option<common_enums::ScaExemptionType>,
payment_id: common_utils::id_type::PaymentId,
) -> RouterResult<types::RouterData<F, Req, Res>> {
let test_mode: Option<bool> = merchant_connector_account.is_test_mode_on();
let auth_type: types::ConnectorAuthType = merchant_connector_account
.get_connector_account_details()
.parse_value("ConnectorAuthType")
.change_context(errors::ApiErrorResponse::InternalServerError)?;
Ok(types::RouterData {
flow: PhantomData,
merchant_id,
customer_id: None,
tenant_id: state.tenant.tenant_id.clone(),
connector_customer: None,
connector: authentication_connector_name,
payment_id: payment_id.get_string_repr().to_owned(),
attempt_id: IRRELEVANT_ATTEMPT_ID_IN_AUTHENTICATION_FLOW.to_owned(),
status: common_enums::AttemptStatus::default(),
payment_method,
payment_method_type: None,
connector_auth_type: auth_type,
description: None,
address,
auth_type: common_enums::AuthenticationType::NoThreeDs,
connector_meta_data: merchant_connector_account.get_metadata(),
connector_wallets_details: merchant_connector_account.get_connector_wallets_details(),
amount_captured: None,
minor_amount_captured: None,
access_token: None,
session_token: None,
reference_id: None,
payment_method_token: None,
recurring_mandate_payment_data: None,
preprocessing_id: None,
payment_method_balance: None,
connector_api_version: None,
request: request_data,
response: Err(types::ErrorResponse::default()),
connector_request_reference_id:
IRRELEVANT_CONNECTOR_REQUEST_REFERENCE_ID_IN_AUTHENTICATION_FLOW.to_owned(),
#[cfg(feature = "payouts")]
payout_method_data: None,
#[cfg(feature = "payouts")]
quote_id: None,
test_mode,
connector_http_status_code: None,
external_latency: None,
apple_pay_flow: None,
frm_metadata: None,
dispute_id: None,
refund_id: None,
payout_id: None,
payment_method_status: None,
connector_response: None,
integrity_check: Ok(()),
additional_merchant_data: None,
header_payload: None,
connector_mandate_request_reference_id: None,
authentication_id: None,
psd2_sca_exemption_type,
raw_connector_response: None,
is_payment_id_from_merchant: None,
l2_l3_data: None,
minor_amount_capturable: None,
authorized_amount: None,
})
}
impl ForeignFrom<common_enums::TransactionStatus> for common_enums::AuthenticationStatus {
fn foreign_from(trans_status: common_enums::TransactionStatus) -> Self {
match trans_status {
common_enums::TransactionStatus::Success => Self::Success,
common_enums::TransactionStatus::Failure
| common_enums::TransactionStatus::Rejected
| common_enums::TransactionStatus::VerificationNotPerformed
| common_enums::TransactionStatus::NotVerified => Self::Failed,
common_enums::TransactionStatus::ChallengeRequired
| common_enums::TransactionStatus::ChallengeRequiredDecoupledAuthentication
| common_enums::TransactionStatus::InformationOnly => Self::Pending,
}
}
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/unified_authentication_service/types.rs | crates/router/src/core/unified_authentication_service/types.rs | use api_models::payments;
use hyperswitch_domain_models::{
errors::api_error_response::{self as errors, NotImplementedMessage},
router_request_types::{
authentication::MessageCategory,
unified_authentication_service::{
UasAuthenticationRequestData, UasPostAuthenticationRequestData,
UasPreAuthenticationRequestData,
},
BrowserInformation,
},
};
use crate::{
core::{errors::RouterResult, payments::helpers::MerchantConnectorAccountType},
db::domain,
routes::SessionState,
};
pub const CTP_MASTERCARD: &str = "ctp_mastercard";
pub const UNIFIED_AUTHENTICATION_SERVICE: &str = "unified_authentication_service";
pub const IRRELEVANT_ATTEMPT_ID_IN_AUTHENTICATION_FLOW: &str =
"irrelevant_attempt_id_in_AUTHENTICATION_flow";
pub const IRRELEVANT_CONNECTOR_REQUEST_REFERENCE_ID_IN_AUTHENTICATION_FLOW: &str =
"irrelevant_connector_request_reference_id_in_AUTHENTICATION_flow";
pub struct ClickToPay;
pub struct ExternalAuthentication;
#[async_trait::async_trait]
pub trait UnifiedAuthenticationService {
#[allow(clippy::too_many_arguments)]
fn get_pre_authentication_request_data(
_payment_method_data: Option<&domain::PaymentMethodData>,
_service_details: Option<payments::CtpServiceDetails>,
_amount: common_utils::types::MinorUnit,
_currency: Option<common_enums::Currency>,
_merchant_details: Option<&hyperswitch_domain_models::router_request_types::unified_authentication_service::MerchantDetails>,
_billing_address: Option<&hyperswitch_domain_models::address::Address>,
_acquirer_bin: Option<String>,
_acquirer_merchant_id: Option<String>,
_payment_method_type: Option<common_enums::PaymentMethodType>,
) -> RouterResult<UasPreAuthenticationRequestData> {
Err(errors::ApiErrorResponse::NotImplemented {
message: NotImplementedMessage::Reason(
"get_pre_authentication_request_data".to_string(),
),
}
.into())
}
#[allow(clippy::too_many_arguments)]
async fn pre_authentication(
_state: &SessionState,
_merchant_id: &common_utils::id_type::MerchantId,
_payment_id: Option<&common_utils::id_type::PaymentId>,
_payment_method_data: Option<&domain::PaymentMethodData>,
_payment_method_type: Option<common_enums::PaymentMethodType>,
_merchant_connector_account: &MerchantConnectorAccountType,
_connector_name: &str,
_authentication_id: &common_utils::id_type::AuthenticationId,
_payment_method: common_enums::PaymentMethod,
_amount: common_utils::types::MinorUnit,
_currency: Option<common_enums::Currency>,
_service_details: Option<payments::CtpServiceDetails>,
_merchant_details: Option<&hyperswitch_domain_models::router_request_types::unified_authentication_service::MerchantDetails>,
_billing_address: Option<&hyperswitch_domain_models::address::Address>,
_acquirer_bin: Option<String>,
_acquirer_merchant_id: Option<String>,
) -> RouterResult<hyperswitch_domain_models::types::UasPreAuthenticationRouterData> {
Err(errors::ApiErrorResponse::NotImplemented {
message: NotImplementedMessage::Reason("pre_authentication".to_string()),
}
.into())
}
#[allow(clippy::too_many_arguments)]
fn get_authentication_request_data(
_browser_details: Option<BrowserInformation>,
_amount: Option<common_utils::types::MinorUnit>,
_currency: Option<common_enums::Currency>,
_message_category: MessageCategory,
_device_channel: payments::DeviceChannel,
_authentication: hyperswitch_domain_models::authentication::Authentication,
_return_url: Option<String>,
_sdk_information: Option<payments::SdkInformation>,
_threeds_method_comp_ind: payments::ThreeDsCompletionIndicator,
_email: Option<common_utils::pii::Email>,
_webhook_url: String,
_force_3ds_challenge: Option<bool>,
_psd2_sca_exemption_type: Option<common_enums::ScaExemptionType>,
) -> RouterResult<UasAuthenticationRequestData> {
Err(errors::ApiErrorResponse::NotImplemented {
message: NotImplementedMessage::Reason(
"get_pre_authentication_request_data".to_string(),
),
}
.into())
}
#[allow(clippy::too_many_arguments)]
async fn authentication(
_state: &SessionState,
_business_profile: &domain::Profile,
_payment_method: &common_enums::PaymentMethod,
_browser_details: Option<BrowserInformation>,
_amount: Option<common_utils::types::MinorUnit>,
_currency: Option<common_enums::Currency>,
_message_category: MessageCategory,
_device_channel: payments::DeviceChannel,
_authentication_data: hyperswitch_domain_models::authentication::Authentication,
_return_url: Option<String>,
_sdk_information: Option<payments::SdkInformation>,
_threeds_method_comp_ind: payments::ThreeDsCompletionIndicator,
_email: Option<common_utils::pii::Email>,
_webhook_url: String,
_merchant_connector_account: &MerchantConnectorAccountType,
_connector_name: &str,
_payment_id: Option<common_utils::id_type::PaymentId>,
_force_3ds_challenge: Option<bool>,
_psd2_sca_exemption_type: Option<common_enums::ScaExemptionType>,
) -> RouterResult<hyperswitch_domain_models::types::UasAuthenticationRouterData> {
Err(errors::ApiErrorResponse::NotImplemented {
message: NotImplementedMessage::Reason("authentication".to_string()),
}
.into())
}
fn get_post_authentication_request_data(
_authentication: Option<hyperswitch_domain_models::authentication::Authentication>,
) -> RouterResult<UasPostAuthenticationRequestData> {
Err(errors::ApiErrorResponse::NotImplemented {
message: NotImplementedMessage::Reason("post_authentication".to_string()),
}
.into())
}
#[allow(clippy::too_many_arguments)]
async fn post_authentication(
_state: &SessionState,
_business_profile: &domain::Profile,
_payment_id: Option<&common_utils::id_type::PaymentId>,
_merchant_connector_account: &MerchantConnectorAccountType,
_connector_name: &str,
_authentication_id: &common_utils::id_type::AuthenticationId,
_payment_method: common_enums::PaymentMethod,
_merchant_id: &common_utils::id_type::MerchantId,
_authentication: Option<&hyperswitch_domain_models::authentication::Authentication>,
) -> RouterResult<hyperswitch_domain_models::types::UasPostAuthenticationRouterData> {
Err(errors::ApiErrorResponse::NotImplemented {
message: NotImplementedMessage::Reason("post_authentication".to_string()),
}
.into())
}
#[allow(clippy::too_many_arguments)]
async fn confirmation(
_state: &SessionState,
_authentication_id: Option<&common_utils::id_type::AuthenticationId>,
_currency: Option<common_enums::Currency>,
_status: common_enums::AttemptStatus,
_service_details: Option<payments::CtpServiceDetails>,
_merchant_connector_account: &MerchantConnectorAccountType,
_connector_name: &str,
_payment_method: common_enums::PaymentMethod,
_net_amount: common_utils::types::MinorUnit,
_payment_id: Option<&common_utils::id_type::PaymentId>,
_merchant_id: &common_utils::id_type::MerchantId,
) -> RouterResult<()> {
Err(errors::ApiErrorResponse::NotImplemented {
message: NotImplementedMessage::Reason("confirmation".to_string()),
}
.into())
}
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/unified_authentication_service/utils.rs | crates/router/src/core/unified_authentication_service/utils.rs | use std::marker::PhantomData;
#[cfg(feature = "v1")]
use api_models::payments::BrowserInformation;
use common_enums::enums::PaymentMethod;
use common_utils::{
ext_traits::{AsyncExt, ValueExt},
types::keymanager::ToEncryptable,
};
use error_stack::{report, ResultExt};
use hyperswitch_domain_models::{
business_profile,
errors::api_error_response::ApiErrorResponse,
ext_traits::OptionExt,
payment_address::PaymentAddress,
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_data_v2::UasFlowData,
router_request_types::unified_authentication_service::{
PostAuthenticationDetails, UasAuthenticationResponseData,
},
type_encryption::AsyncLift,
};
use masking::{ExposeInterface, PeekInterface};
use super::types::{
IRRELEVANT_ATTEMPT_ID_IN_AUTHENTICATION_FLOW,
IRRELEVANT_CONNECTOR_REQUEST_REFERENCE_ID_IN_AUTHENTICATION_FLOW,
};
use crate::{
consts::DEFAULT_SESSION_EXPIRY,
core::{
errors::{
utils::{ConnectorErrorExt, StorageErrorExt},
RouterResult,
},
payment_methods, payments,
},
db::domain,
services::{self, execute_connector_processing_step},
types::{api, transformers::ForeignFrom},
SessionState,
};
pub async fn do_auth_connector_call<F, Req, Res>(
state: &SessionState,
authentication_connector_name: String,
router_data: RouterData<F, Req, Res>,
) -> RouterResult<RouterData<F, Req, Res>>
where
Req: std::fmt::Debug + Clone + 'static,
Res: std::fmt::Debug + Clone + 'static,
F: std::fmt::Debug + Clone + 'static,
dyn api::Connector + Sync: services::api::ConnectorIntegration<F, Req, Res>,
dyn api::ConnectorV2 + Sync: services::api::ConnectorIntegrationV2<F, UasFlowData, Req, Res>,
{
let connector_data =
api::AuthenticationConnectorData::get_connector_by_name(&authentication_connector_name)?;
let connector_integration: services::BoxedUnifiedAuthenticationServiceInterface<F, Req, Res> =
connector_data.connector.get_connector_integration();
let router_data = execute_connector_processing_step(
state,
connector_integration,
&router_data,
payments::CallConnectorAction::Trigger,
None,
None,
)
.await
.to_payment_failed_response()?;
Ok(router_data)
}
#[allow(clippy::too_many_arguments)]
pub fn construct_uas_router_data<F: Clone, Req, Res>(
state: &SessionState,
authentication_connector_name: String,
payment_method: PaymentMethod,
merchant_id: common_utils::id_type::MerchantId,
address: Option<PaymentAddress>,
request_data: Req,
merchant_connector_account: &payments::helpers::MerchantConnectorAccountType,
authentication_id: Option<common_utils::id_type::AuthenticationId>,
payment_id: Option<common_utils::id_type::PaymentId>,
) -> RouterResult<RouterData<F, Req, Res>> {
let auth_type: ConnectorAuthType = merchant_connector_account
.get_connector_account_details()
.parse_value("ConnectorAuthType")
.change_context(ApiErrorResponse::InternalServerError)
.attach_printable("Error while parsing ConnectorAuthType")?;
Ok(RouterData {
flow: PhantomData,
merchant_id,
customer_id: None,
connector_customer: None,
connector: authentication_connector_name,
payment_id: payment_id
.map(|id| id.get_string_repr().to_owned())
.unwrap_or_default(),
tenant_id: state.tenant.tenant_id.clone(),
attempt_id: IRRELEVANT_ATTEMPT_ID_IN_AUTHENTICATION_FLOW.to_owned(),
status: common_enums::AttemptStatus::default(),
payment_method,
payment_method_type: None,
connector_auth_type: auth_type,
description: None,
address: address.unwrap_or_default(),
auth_type: common_enums::AuthenticationType::default(),
connector_meta_data: merchant_connector_account.get_metadata().clone(),
connector_wallets_details: merchant_connector_account.get_connector_wallets_details(),
amount_captured: None,
minor_amount_captured: None,
access_token: None,
session_token: None,
reference_id: None,
payment_method_token: None,
recurring_mandate_payment_data: None,
preprocessing_id: None,
payment_method_balance: None,
connector_api_version: None,
request: request_data,
response: Err(ErrorResponse::default()),
connector_request_reference_id:
IRRELEVANT_CONNECTOR_REQUEST_REFERENCE_ID_IN_AUTHENTICATION_FLOW.to_owned(),
#[cfg(feature = "payouts")]
payout_method_data: None,
#[cfg(feature = "payouts")]
quote_id: None,
test_mode: None,
connector_http_status_code: None,
external_latency: None,
apple_pay_flow: None,
frm_metadata: None,
dispute_id: None,
refund_id: None,
payout_id: None,
payment_method_status: None,
connector_response: None,
integrity_check: Ok(()),
additional_merchant_data: None,
header_payload: None,
connector_mandate_request_reference_id: None,
authentication_id,
psd2_sca_exemption_type: None,
raw_connector_response: None,
is_payment_id_from_merchant: None,
l2_l3_data: None,
minor_amount_capturable: None,
authorized_amount: None,
})
}
#[allow(clippy::too_many_arguments)]
#[cfg(feature = "v1")]
pub async fn external_authentication_update_trackers<F: Clone, Req>(
state: &SessionState,
router_data: RouterData<F, Req, UasAuthenticationResponseData>,
authentication: hyperswitch_domain_models::authentication::Authentication,
acquirer_details: Option<
hyperswitch_domain_models::router_request_types::authentication::AcquirerDetails,
>,
merchant_key_store: &hyperswitch_domain_models::merchant_key_store::MerchantKeyStore,
billing_address: Option<hyperswitch_domain_models::address::Address>,
shipping_address: Option<hyperswitch_domain_models::address::Address>,
email: Option<common_utils::pii::Email>,
browser_info: Option<BrowserInformation>,
device_details: Option<api_models::payments::DeviceDetails>,
merchant_category_code: Option<common_enums::MerchantCategoryCode>,
merchant_country_code: Option<common_types::payments::MerchantCountryCode>,
) -> RouterResult<hyperswitch_domain_models::authentication::Authentication> {
let key_state = state.into();
let authentication_update = match router_data.response {
Ok(response) => match response {
UasAuthenticationResponseData::PreAuthentication {
authentication_details,
} => {
let billing_details_encoded = billing_address
.clone()
.map(|billing| {
common_utils::ext_traits::Encode::encode_to_value(&billing)
.map(masking::Secret::<serde_json::Value>::new)
})
.transpose()
.change_context(ApiErrorResponse::InternalServerError)
.attach_printable("Unable to encode billing details to serde_json::Value")?;
let shipping_details_encoded = shipping_address
.clone()
.map(|shipping| {
common_utils::ext_traits::Encode::encode_to_value(&shipping)
.map(masking::Secret::<serde_json::Value>::new)
})
.transpose()
.change_context(ApiErrorResponse::InternalServerError)
.attach_printable("Unable to encode shipping details to serde_json::Value")?;
let encrypted_data = domain::types::crypto_operation(
&key_state,
common_utils::type_name!(hyperswitch_domain_models::authentication::Authentication),
domain::types::CryptoOperation::BatchEncrypt(
hyperswitch_domain_models::authentication::UpdateEncryptableAuthentication::to_encryptable(
hyperswitch_domain_models::authentication::UpdateEncryptableAuthentication {
billing_address: billing_details_encoded,
shipping_address: shipping_details_encoded,
},
),
),
common_utils::types::keymanager::Identifier::Merchant(
merchant_key_store
.merchant_id
.clone(),
),
merchant_key_store.key.peek(),
)
.await
.and_then(|val| val.try_into_batchoperation())
.change_context(ApiErrorResponse::InternalServerError)
.attach_printable("Unable to encrypt authentication data".to_string())?;
let encrypted_data = hyperswitch_domain_models::authentication::FromRequestEncryptableAuthentication::from_encryptable(encrypted_data)
.change_context(ApiErrorResponse::InternalServerError)
.attach_printable("Unable to get encrypted data for authentication after encryption")?;
let email_encrypted = email
.clone()
.async_lift(|inner| async {
domain::types::crypto_operation(
&key_state,
common_utils::type_name!(
hyperswitch_domain_models::authentication::Authentication
),
domain::types::CryptoOperation::EncryptOptional(
inner.map(|inner| inner.expose()),
),
common_utils::types::keymanager::Identifier::Merchant(
merchant_key_store.merchant_id.clone(),
),
merchant_key_store.key.peek(),
)
.await
.and_then(|val| val.try_into_optionaloperation())
})
.await
.change_context(ApiErrorResponse::InternalServerError)
.attach_printable("Unable to encrypt email")?;
let browser_info = browser_info
.as_ref()
.map(common_utils::ext_traits::Encode::encode_to_value)
.transpose()
.change_context(ApiErrorResponse::InvalidDataValue {
field_name: "browser_information",
})?;
Ok(
hyperswitch_domain_models::authentication::AuthenticationUpdate::PreAuthenticationUpdate {
earliest_supported_version:authentication_details.maximum_supported_3ds_version.clone(),
latest_supported_version: authentication_details.maximum_supported_3ds_version.clone(),
threeds_server_transaction_id: authentication_details
.threeds_server_transaction_id
.ok_or(ApiErrorResponse::InternalServerError)
.attach_printable(
"missing threeds_server_transaction_id in PreAuthentication Details",
)?,
maximum_supported_3ds_version: authentication_details
.maximum_supported_3ds_version
.clone()
.ok_or(ApiErrorResponse::InternalServerError)
.attach_printable(
"missing maximum_supported_3ds_version in PreAuthentication Details",
)?,
connector_authentication_id: authentication_details
.connector_authentication_id
.ok_or(ApiErrorResponse::InternalServerError)
.attach_printable(
"missing connector_authentication_id in PreAuthentication Details",
)?,
three_ds_method_data: authentication_details.three_ds_method_data,
three_ds_method_url: authentication_details.three_ds_method_url,
message_version: authentication_details
.message_version
.ok_or(ApiErrorResponse::InternalServerError)
.attach_printable("missing message_version in PreAuthentication Details")?,
connector_metadata: authentication_details.connector_metadata.clone(),
authentication_status: common_enums::AuthenticationStatus::Pending,
acquirer_bin: acquirer_details
.as_ref()
.map(|acquirer_details| acquirer_details.acquirer_bin.clone()),
acquirer_merchant_id: acquirer_details
.as_ref()
.map(|acquirer_details| acquirer_details.acquirer_merchant_id.clone()),
acquirer_country_code: acquirer_details
.and_then(|acquirer_details| acquirer_details.acquirer_country_code),
directory_server_id: authentication_details.directory_server_id.clone(),
browser_info: Box::new(browser_info),
email:email_encrypted,
billing_address: Box::new(encrypted_data.billing_address),
shipping_address: Box::new(encrypted_data.shipping_address),
scheme_id: authentication_details.scheme_id.clone(),
merchant_category_code,
merchant_country_code: merchant_country_code.map(|merchant_country_code| merchant_country_code.get_country_code()),
billing_country: billing_address
.clone()
.and_then(|billing| billing.address.clone().and_then(|address| address.country.map(|country| country.to_string()))),
shipping_country: shipping_address
.clone()
.and_then(|shipping| shipping.address.clone().and_then(|address| address.country.map(|country| country.to_string()))),
},
)
}
UasAuthenticationResponseData::Authentication {
authentication_details,
} => {
let authentication_status = common_enums::AuthenticationStatus::foreign_from(
authentication_details.trans_status.clone(),
);
authentication_details
.authentication_value
.async_map(|auth_val| {
payment_methods::vault::create_tokenize(
state,
auth_val.expose(),
None,
authentication
.authentication_id
.get_string_repr()
.to_string(),
merchant_key_store.key.get_inner(),
)
})
.await
.transpose()?;
Ok(
hyperswitch_domain_models::authentication::AuthenticationUpdate::AuthenticationUpdate {
trans_status: authentication_details.trans_status,
acs_url: authentication_details.authn_flow_type.get_acs_url(),
challenge_request: authentication_details
.authn_flow_type
.get_challenge_request(),
challenge_request_key: authentication_details
.authn_flow_type
.get_challenge_request_key(),
acs_reference_number: authentication_details
.authn_flow_type
.get_acs_reference_number(),
acs_trans_id: authentication_details.authn_flow_type.get_acs_trans_id(),
acs_signed_content: authentication_details
.authn_flow_type
.get_acs_signed_content(),
authentication_type: authentication_details
.authn_flow_type
.get_decoupled_authentication_type(),
authentication_status,
connector_metadata: authentication_details.connector_metadata,
ds_trans_id: authentication_details.ds_trans_id,
eci: authentication_details.eci,
challenge_code: authentication_details.challenge_code,
challenge_cancel: authentication_details.challenge_cancel,
challenge_code_reason: authentication_details.challenge_code_reason,
message_extension: authentication_details.message_extension,
device_type: device_details
.as_ref()
.and_then(|details| details.device_type.clone()),
device_brand: device_details
.as_ref()
.and_then(|details| details.device_brand.clone()),
device_os: device_details
.as_ref()
.and_then(|details| details.device_os.clone()),
device_display: device_details
.as_ref()
.and_then(|details| details.device_display.clone()),
},
)
}
UasAuthenticationResponseData::PostAuthentication {
authentication_details,
} => {
let trans_status = authentication_details
.trans_status
.ok_or(ApiErrorResponse::InternalServerError)
.attach_printable("missing trans_status in PostAuthentication Details")?;
authentication_details
.dynamic_data_details
.and_then(|details| details.dynamic_data_value)
.map(ExposeInterface::expose)
.async_map(|auth_val| {
payment_methods::vault::create_tokenize(
state,
auth_val,
None,
authentication
.authentication_id
.get_string_repr()
.to_string(),
merchant_key_store.key.get_inner(),
)
})
.await
.transpose()?;
Ok(
hyperswitch_domain_models::authentication::AuthenticationUpdate::PostAuthenticationUpdate {
authentication_status: common_enums::AuthenticationStatus::foreign_from(
trans_status.clone(),
),
trans_status,
eci: authentication_details.eci,
challenge_cancel: authentication_details.challenge_cancel,
challenge_code_reason: authentication_details.challenge_code_reason,
},
)
}
UasAuthenticationResponseData::Confirmation { .. } => Err(
ApiErrorResponse::InternalServerError,
)
.attach_printable("unexpected api confirmation in external authentication flow."),
},
Err(error) => Ok(
hyperswitch_domain_models::authentication::AuthenticationUpdate::ErrorUpdate {
connector_authentication_id: error.connector_transaction_id,
authentication_status: common_enums::AuthenticationStatus::Failed,
error_message: error
.reason
.map(|reason| format!("message: {}, reason: {}", error.message, reason))
.or(Some(error.message)),
error_code: Some(error.code),
},
),
}?;
state
.store
.update_authentication_by_merchant_id_authentication_id(
authentication,
authentication_update,
merchant_key_store,
&key_state,
)
.await
.change_context(ApiErrorResponse::InternalServerError)
.attach_printable("Error while updating authentication")
}
pub fn get_checkout_event_status_and_reason(
attempt_status: common_enums::AttemptStatus,
) -> (Option<String>, Option<String>) {
match attempt_status {
common_enums::AttemptStatus::Charged | common_enums::AttemptStatus::Authorized => (
Some("01".to_string()),
Some("The payment was successful".to_string()),
),
_ => (
Some("03".to_string()),
Some("The payment was not successful".to_string()),
),
}
}
pub fn authenticate_authentication_client_secret_and_check_expiry(
req_client_secret: &String,
authentication: &hyperswitch_domain_models::authentication::Authentication,
) -> RouterResult<()> {
let stored_client_secret = authentication
.authentication_client_secret
.clone()
.get_required_value("authentication_client_secret")
.change_context(ApiErrorResponse::MissingRequiredField {
field_name: "client_secret",
})
.attach_printable("client secret not found in db")?;
if req_client_secret != &stored_client_secret {
Err(report!(ApiErrorResponse::ClientSecretInvalid))
} else {
let current_timestamp = common_utils::date_time::now();
let session_expiry = authentication
.created_at
.saturating_add(time::Duration::seconds(DEFAULT_SESSION_EXPIRY));
if current_timestamp > session_expiry {
Err(report!(ApiErrorResponse::ClientSecretExpired))
} else {
Ok(())
}
}
}
#[cfg(feature = "v1")]
pub async fn get_auth_multi_token_from_external_vault<F, Req>(
state: &SessionState,
platform: &domain::Platform,
business_profile: &domain::Profile,
router_data: &RouterData<F, Req, UasAuthenticationResponseData>,
) -> RouterResult<Option<api_models::authentication::AuthenticationVaultTokenData>> {
if let Ok(UasAuthenticationResponseData::PostAuthentication {
authentication_details,
}) = router_data.response.clone()
{
match business_profile.external_vault_details.clone() {
business_profile::ExternalVaultDetails::ExternalVaultEnabled(
external_vault_details,
) => {
let external_vault_mca_id = external_vault_details.vault_connector_id.clone();
let merchant_connector_account_details = state
.store
.find_by_merchant_connector_account_merchant_id_merchant_connector_id(
platform.get_processor().get_account().get_id(),
&external_vault_mca_id,
platform.get_processor().get_key_store(),
)
.await
.to_not_found_response(ApiErrorResponse::MerchantConnectorAccountNotFound {
id: external_vault_mca_id.get_string_repr().to_string(),
})?;
let vault_data = get_vault_details(authentication_details)?;
// decide which fields to tokenize in vault
let vault_custom_data = payment_methods::get_payment_method_custom_data(
vault_data,
external_vault_details.vault_token_selector,
)?;
let external_vault_response =
Box::pin(payment_methods::vault_payment_method_external_v1(
state,
&vault_custom_data,
platform.get_processor().get_account(),
merchant_connector_account_details,
Some(true),
))
.await?;
let vault_token_data = external_vault_response
.vault_id
.get_auth_vault_token_data()?;
Ok(Some(vault_token_data))
}
business_profile::ExternalVaultDetails::Skip => {
Err(ApiErrorResponse::InternalServerError)
.attach_printable("External Vault Details are missing")
}
}
} else {
Ok(None)
}
}
#[cfg(feature = "v1")]
fn get_vault_details(
auth_details: PostAuthenticationDetails,
) -> RouterResult<hyperswitch_domain_models::vault::PaymentMethodVaultingData> {
// if raw card details are present, it have the highest priority
// if network_token details are present, then it is returned if raw card details are not present
// throw error if both are not present
match (auth_details.raw_card_details, auth_details.token_details) {
(Some(card_details), _) => Ok(
hyperswitch_domain_models::vault::PaymentMethodVaultingData::Card(
api_models::payment_methods::CardDetail {
card_number: card_details.pan.clone(),
card_exp_month: card_details.expiration_month,
card_exp_year: card_details.expiration_year,
card_cvc: card_details.card_security_code,
card_issuer: None,
card_network: None,
card_type: None,
card_issuing_country: None,
card_issuing_country_code: None,
card_holder_name: None,
nick_name: None,
},
),
),
(None, Some(token_data)) => {
let cryptogram = auth_details
.dynamic_data_details
.and_then(|dynamic_data| dynamic_data.dynamic_data_value);
Ok(
hyperswitch_domain_models::vault::PaymentMethodVaultingData::NetworkToken(
hyperswitch_domain_models::payment_method_data::NetworkTokenDetails {
network_token: token_data.payment_token.clone(),
network_token_exp_month: token_data.token_expiration_month.clone(),
network_token_exp_year: token_data.token_expiration_year.clone(),
cryptogram,
card_issuer: None,
card_network: None,
card_type: None,
card_issuing_country: None,
card_holder_name: None,
nick_name: None,
},
),
)
}
(None, None) => Err(ApiErrorResponse::MissingRequiredField {
field_name: "Either Card or Network Token details",
}
.into()),
}
}
#[cfg(feature = "v1")]
pub fn get_authentication_payment_method_data<F, Req>(
router_data: &RouterData<F, Req, UasAuthenticationResponseData>,
) -> Option<api_models::authentication::AuthenticationPaymentMethodDataResponse> {
if let Ok(UasAuthenticationResponseData::PostAuthentication {
authentication_details,
}) = router_data.response.clone()
{
authentication_details.into()
} else {
None
}
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/revenue_recovery/api.rs | crates/router/src/core/revenue_recovery/api.rs | use actix_web::{web, Responder};
use api_models::{payments as payments_api, payments as api_payments};
use common_utils::id_type;
use error_stack::{report, FutureExt, ResultExt};
use hyperswitch_domain_models::{payments as payments_domain, platform::Platform};
use crate::{
core::{
errors::{self, RouterResult},
payments::{self, operations::Operation},
webhooks::recovery_incoming,
},
db::{
errors::{RouterResponse, StorageErrorExt},
storage::revenue_recovery_redis_operation::RedisTokenManager,
},
logger,
routes::{app::ReqState, SessionState},
services,
types::{
api::payments as api_types,
domain,
storage::{self, revenue_recovery as revenue_recovery_types},
transformers::ForeignFrom,
},
};
pub async fn call_psync_api(
state: &SessionState,
global_payment_id: &id_type::GlobalPaymentId,
revenue_recovery_data: &revenue_recovery_types::RevenueRecoveryPaymentData,
force_sync_bool: bool,
expand_attempts_bool: bool,
) -> RouterResult<payments_domain::PaymentStatusData<api_types::PSync>> {
let operation = payments::operations::PaymentGet;
let req = payments_api::PaymentsRetrieveRequest {
force_sync: force_sync_bool,
param: None,
expand_attempts: expand_attempts_bool,
return_raw_connector_response: None,
merchant_connector_details: None,
};
let platform_from_revenue_recovery_data = Platform::new(
revenue_recovery_data.merchant_account.clone(),
revenue_recovery_data.key_store.clone(),
revenue_recovery_data.merchant_account.clone(),
revenue_recovery_data.key_store.clone(),
None,
);
// TODO : Use api handler instead of calling get_tracker and payments_operation_core
// Get the tracker related information. This includes payment intent and payment attempt
let get_tracker_response = operation
.to_get_tracker()?
.get_trackers(
state,
global_payment_id,
&req,
&platform_from_revenue_recovery_data,
&revenue_recovery_data.profile,
&payments_domain::HeaderPayload::default(),
)
.await?;
let (payment_data, _req, _, _, _, _) = Box::pin(payments::payments_operation_core::<
api_types::PSync,
_,
_,
_,
payments_domain::PaymentStatusData<api_types::PSync>,
>(
state,
state.get_req_state(),
platform_from_revenue_recovery_data,
&revenue_recovery_data.profile,
operation,
req,
get_tracker_response,
payments::CallConnectorAction::Trigger,
payments_domain::HeaderPayload::default(),
))
.await?;
Ok(payment_data)
}
pub async fn call_proxy_api(
state: &SessionState,
payment_intent: &payments_domain::PaymentIntent,
revenue_recovery_payment_data: &storage::revenue_recovery::RevenueRecoveryPaymentData,
revenue_recovery: &payments_api::PaymentRevenueRecoveryMetadata,
payment_processor_token: &str,
) -> RouterResult<payments_domain::PaymentConfirmData<api_types::Authorize>> {
let operation = payments::operations::proxy_payments_intent::PaymentProxyIntent;
let recurring_details = api_models::mandates::ProcessorPaymentToken {
processor_payment_token: payment_processor_token.to_string(),
merchant_connector_id: Some(revenue_recovery.get_merchant_connector_id_for_api_request()),
};
let req = payments_api::ProxyPaymentsRequest {
return_url: None,
amount: payments_api::AmountDetails::new(payment_intent.amount_details.clone().into()),
recurring_details,
shipping: None,
browser_info: None,
connector: revenue_recovery.connector.to_string(),
merchant_connector_id: revenue_recovery.get_merchant_connector_id_for_api_request(),
};
logger::info!(
"Call made to payments proxy api , with the request body {:?}",
req
);
let platform_from_revenue_recovery_payment_data = Platform::new(
revenue_recovery_payment_data.merchant_account.clone(),
revenue_recovery_payment_data.key_store.clone(),
revenue_recovery_payment_data.merchant_account.clone(),
revenue_recovery_payment_data.key_store.clone(),
None,
);
// TODO : Use api handler instead of calling get_tracker and payments_operation_core
// Get the tracker related information. This includes payment intent and payment attempt
let get_tracker_response = operation
.to_get_tracker()?
.get_trackers(
state,
payment_intent.get_id(),
&req,
&platform_from_revenue_recovery_payment_data,
&revenue_recovery_payment_data.profile,
&payments_domain::HeaderPayload::default(),
)
.await?;
let (payment_data, _req, _, _) = Box::pin(payments::proxy_for_payments_operation_core::<
api_types::Authorize,
_,
_,
_,
payments_domain::PaymentConfirmData<api_types::Authorize>,
>(
state,
state.get_req_state(),
platform_from_revenue_recovery_payment_data,
revenue_recovery_payment_data.profile.clone(),
operation,
req,
get_tracker_response,
payments::CallConnectorAction::Trigger,
payments_domain::HeaderPayload::default(),
None,
))
.await?;
Ok(payment_data)
}
pub async fn update_payment_intent_api(
state: &SessionState,
global_payment_id: id_type::GlobalPaymentId,
revenue_recovery_payment_data: &storage::revenue_recovery::RevenueRecoveryPaymentData,
update_req: payments_api::PaymentsUpdateIntentRequest,
) -> RouterResult<payments_domain::PaymentIntentData<api_types::PaymentUpdateIntent>> {
// TODO : Use api handler instead of calling payments_intent_operation_core
let operation = payments::operations::PaymentUpdateIntent;
let platform_from_revenue_recovery_payment_data = Platform::new(
revenue_recovery_payment_data.merchant_account.clone(),
revenue_recovery_payment_data.key_store.clone(),
revenue_recovery_payment_data.merchant_account.clone(),
revenue_recovery_payment_data.key_store.clone(),
None,
);
let (payment_data, _req, _) = payments::payments_intent_operation_core::<
api_types::PaymentUpdateIntent,
_,
_,
payments_domain::PaymentIntentData<api_types::PaymentUpdateIntent>,
>(
state,
state.get_req_state(),
platform_from_revenue_recovery_payment_data,
revenue_recovery_payment_data.profile.clone(),
operation,
update_req,
global_payment_id,
payments_domain::HeaderPayload::default(),
)
.await?;
Ok(payment_data)
}
pub async fn record_internal_attempt_api(
state: &SessionState,
payment_intent: &payments_domain::PaymentIntent,
revenue_recovery_payment_data: &storage::revenue_recovery::RevenueRecoveryPaymentData,
revenue_recovery_metadata: &payments_api::PaymentRevenueRecoveryMetadata,
card_info: payments_api::AdditionalCardInfo,
payment_processor_token: &str,
) -> RouterResult<payments_api::PaymentAttemptRecordResponse> {
let revenue_recovery_attempt_data =
recovery_incoming::RevenueRecoveryAttempt::get_revenue_recovery_attempt(
payment_intent,
revenue_recovery_metadata,
&revenue_recovery_payment_data.billing_mca,
card_info,
payment_processor_token,
)
.change_context(errors::ApiErrorResponse::GenericNotFoundError {
message: "get_revenue_recovery_attempt was not constructed".to_string(),
})?;
let request_payload = revenue_recovery_attempt_data
.create_payment_record_request(
state,
&revenue_recovery_payment_data.billing_mca.id,
Some(
revenue_recovery_metadata
.active_attempt_payment_connector_id
.clone(),
),
Some(revenue_recovery_metadata.connector),
common_enums::TriggeredBy::Internal,
)
.await
.change_context(errors::ApiErrorResponse::GenericNotFoundError {
message: "Cannot Create the payment record Request".to_string(),
})?;
let platform_from_revenue_recovery_payment_data = Platform::new(
revenue_recovery_payment_data.merchant_account.clone(),
revenue_recovery_payment_data.key_store.clone(),
revenue_recovery_payment_data.merchant_account.clone(),
revenue_recovery_payment_data.key_store.clone(),
None,
);
let attempt_response = Box::pin(payments::record_attempt_core(
state.clone(),
state.get_req_state(),
platform_from_revenue_recovery_payment_data,
revenue_recovery_payment_data.profile.clone(),
request_payload,
payment_intent.id.clone(),
hyperswitch_domain_models::payments::HeaderPayload::default(),
))
.await;
match attempt_response {
Ok(services::ApplicationResponse::JsonWithHeaders((attempt_response, _))) => {
Ok(attempt_response)
}
Ok(_) => Err(errors::ApiErrorResponse::PaymentNotFound)
.attach_printable("Unexpected response from record attempt core"),
error @ Err(_) => {
router_env::logger::error!(?error);
Err(errors::ApiErrorResponse::PaymentNotFound)
.attach_printable("failed to record attempt for revenue recovery workflow")
}
}
}
pub async fn custom_revenue_recovery_core(
state: SessionState,
req_state: ReqState,
platform: Platform,
profile: domain::Profile,
request: api_models::payments::RecoveryPaymentsCreate,
) -> RouterResponse<payments_api::RecoveryPaymentsResponse> {
let store = state.store.as_ref();
let payment_merchant_connector_account_id = request.payment_merchant_connector_id.to_owned();
// Find the payment & billing merchant connector id at the top level to avoid multiple DB calls.
let payment_merchant_connector_account = store
.find_merchant_connector_account_by_id(
&payment_merchant_connector_account_id,
platform.get_processor().get_key_store(),
)
.await
.to_not_found_response(errors::ApiErrorResponse::MerchantConnectorAccountNotFound {
id: payment_merchant_connector_account_id
.clone()
.get_string_repr()
.to_string(),
})?;
let billing_connector_account = store
.find_merchant_connector_account_by_id(
&request.billing_merchant_connector_id.clone(),
platform.get_processor().get_key_store(),
)
.await
.to_not_found_response(errors::ApiErrorResponse::MerchantConnectorAccountNotFound {
id: request
.billing_merchant_connector_id
.clone()
.get_string_repr()
.to_string(),
})?;
let recovery_intent =
recovery_incoming::RevenueRecoveryInvoice::get_or_create_custom_recovery_intent(
request.clone(),
&state,
&req_state,
&platform,
&profile,
)
.await
.change_context(errors::ApiErrorResponse::GenericNotFoundError {
message: format!(
"Failed to load recovery intent for merchant reference id : {:?}",
request.merchant_reference_id.to_owned()
)
.to_string(),
})?;
let (revenue_recovery_attempt_data, updated_recovery_intent) =
recovery_incoming::RevenueRecoveryAttempt::load_recovery_attempt_from_api(
request.clone(),
&state,
&req_state,
&platform,
&profile,
recovery_intent.clone(),
payment_merchant_connector_account,
)
.await
.change_context(errors::ApiErrorResponse::GenericNotFoundError {
message: format!(
"Failed to load recovery attempt for merchant reference id : {:?}",
request.merchant_reference_id.to_owned()
)
.to_string(),
})?;
let intent_retry_count = updated_recovery_intent
.feature_metadata
.as_ref()
.and_then(|metadata| metadata.get_retry_count())
.ok_or(report!(errors::ApiErrorResponse::GenericNotFoundError {
message: "Failed to fetch retry count from intent feature metadata".to_string(),
}))?;
router_env::logger::info!("Intent retry count: {:?}", intent_retry_count);
let recovery_action = recovery_incoming::RecoveryAction {
action: request.action.to_owned(),
};
let mca_retry_threshold = billing_connector_account
.get_retry_threshold()
.ok_or(report!(errors::ApiErrorResponse::GenericNotFoundError {
message: "Failed to fetch retry threshold from billing merchant connector account"
.to_string(),
}))?;
recovery_action
.handle_action(
&state,
&profile,
&platform,
&billing_connector_account,
mca_retry_threshold,
intent_retry_count,
&(
Some(revenue_recovery_attempt_data),
updated_recovery_intent.clone(),
),
)
.await
.change_context(errors::ApiErrorResponse::GenericNotFoundError {
message: "Unexpected response from recovery core".to_string(),
})?;
let response = api_models::payments::RecoveryPaymentsResponse {
id: updated_recovery_intent.payment_id.to_owned(),
intent_status: updated_recovery_intent.status.to_owned(),
merchant_reference_id: updated_recovery_intent.merchant_reference_id.to_owned(),
};
Ok(hyperswitch_domain_models::api::ApplicationResponse::Json(
response,
))
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/revenue_recovery/types.rs | crates/router/src/core/revenue_recovery/types.rs | use std::{marker::PhantomData, str::FromStr};
use api_models::{
enums as api_enums,
payments::{
AmountDetails, PaymentRevenueRecoveryMetadata, PaymentsUpdateIntentRequest,
ProxyPaymentsRequest,
},
};
use common_utils::{
self,
ext_traits::{AsyncExt, OptionExt, ValueExt},
id_type,
};
use diesel_models::{
enums, payment_intent, process_tracker::business_status, types as diesel_types,
};
use error_stack::{self, ResultExt};
use hyperswitch_domain_models::{
api::ApplicationResponse,
business_profile, merchant_connector_account,
payments::{
self as domain_payments, payment_attempt::PaymentAttempt, PaymentConfirmData,
PaymentIntent, PaymentIntentData, PaymentStatusData,
},
platform::Platform,
router_data_v2::{self, flow_common_types},
router_flow_types,
router_request_types::revenue_recovery as revenue_recovery_request,
router_response_types::revenue_recovery as revenue_recovery_response,
ApiModelToDieselModelConvertor,
};
use time::PrimitiveDateTime;
use super::errors::StorageErrorExt;
use crate::{
consts,
core::{
errors::{self, RouterResult},
payments::{self, helpers, operations::Operation, transformers::GenerateResponse},
revenue_recovery::{self as revenue_recovery_core, pcr, perform_calculate_workflow},
webhooks::{
create_event_and_trigger_outgoing_webhook, recovery_incoming as recovery_incoming_flow,
},
},
db::StorageInterface,
logger,
routes::SessionState,
services::{self, connector_integration_interface::RouterDataConversion},
types::{
self, api as api_types, api::payments as payments_types, domain, storage,
transformers::ForeignInto,
},
workflows::{
payment_sync,
revenue_recovery::{self, get_schedule_time_to_retry_mit_payments},
},
};
type RecoveryResult<T> = error_stack::Result<T, errors::RecoveryError>;
pub const REVENUE_RECOVERY: &str = "revenue_recovery";
/// The status of Passive Churn Payments
#[derive(Clone, Debug, serde::Deserialize, serde::Serialize)]
pub enum RevenueRecoveryPaymentIntentStatus {
Succeeded,
Failed,
Processing,
InvalidStatus(String),
PartialCharged,
// Cancelled,
}
impl RevenueRecoveryPaymentIntentStatus {
pub(crate) async fn update_pt_status_based_on_intent_status_for_execute_payment(
&self,
db: &dyn StorageInterface,
execute_task_process: &storage::ProcessTracker,
) -> Result<(), errors::ProcessTrackerError> {
logger::info!("Entering update_pt_status_based_on_intent_status_for_execute_payment");
match &self {
Self::Succeeded | Self::PartialCharged | Self::Failed | Self::Processing => {
// finish the current execute task
db.finish_process_with_business_status(
execute_task_process.clone(),
business_status::EXECUTE_WORKFLOW_COMPLETE_FOR_PSYNC,
)
.await?;
}
Self::InvalidStatus(action) => {
logger::debug!(
"Invalid Attempt Status for the Recovery Payment : {}",
action
);
let pt_update = storage::ProcessTrackerUpdate::StatusUpdate {
status: enums::ProcessTrackerStatus::Review,
business_status: Some(String::from(business_status::EXECUTE_WORKFLOW_COMPLETE)),
};
// update the process tracker status as Review
db.update_process(execute_task_process.clone(), pt_update)
.await?;
}
};
Ok(())
}
#[allow(clippy::too_many_arguments)]
pub(crate) async fn update_pt_status_based_on_attempt_status_for_payments_sync(
&self,
state: &SessionState,
payment_intent: &PaymentIntent,
process_tracker: storage::ProcessTracker,
profile: &domain::Profile,
platform: domain::Platform,
revenue_recovery_payment_data: &storage::revenue_recovery::RevenueRecoveryPaymentData,
payment_attempt: PaymentAttempt,
revenue_recovery_metadata: &mut PaymentRevenueRecoveryMetadata,
) -> Result<(), errors::ProcessTrackerError> {
let connector_customer_id = payment_intent
.extract_connector_customer_id_from_payment_intent()
.change_context(errors::RecoveryError::ValueNotFound)
.attach_printable("Failed to extract customer ID from payment intent")?;
let db = &*state.store;
let recovery_payment_intent =
hyperswitch_domain_models::revenue_recovery::RecoveryPaymentIntent::from(
payment_intent,
);
let recovery_payment_attempt =
hyperswitch_domain_models::revenue_recovery::RecoveryPaymentAttempt::from(
&payment_attempt,
);
let recovery_payment_tuple = recovery_incoming_flow::RecoveryPaymentTuple::new(
&recovery_payment_intent,
&recovery_payment_attempt,
);
let used_token = get_payment_processor_token_id_from_payment_attempt(&payment_attempt);
let retry_count = process_tracker.retry_count;
let psync_response = revenue_recovery_payment_data
.psync_data
.as_ref()
.ok_or(errors::RecoveryError::ValueNotFound)
.attach_printable("Psync data not found in revenue recovery payment data")?;
let intent_status: Self = psync_response.payment_intent.status.foreign_into();
let event_status = common_enums::EventType::from(intent_status.clone());
match intent_status {
Self::Succeeded => {
// finish psync task as the payment was a success
db.as_scheduler()
.finish_process_with_business_status(
process_tracker.clone(),
business_status::PSYNC_WORKFLOW_COMPLETE,
)
.await?;
// publish events to kafka
if let Err(e) = recovery_incoming_flow::RecoveryPaymentTuple::publish_revenue_recovery_event_to_kafka(
state,
&recovery_payment_tuple,
Some(retry_count+1)
)
.await{
router_env::logger::error!(
"Failed to publish revenue recovery event to kafka: {:?}",
e
);
};
// update the status of token in redis
let _update_error_code = storage::revenue_recovery_redis_operation::RedisTokenManager::update_payment_processor_token_error_code_from_process_tracker(
state,
&connector_customer_id,
&None,
&None,
used_token.as_deref(),
)
.await;
// unlocking the token
let _unlock_the_connector_customer_id = storage::revenue_recovery_redis_operation::RedisTokenManager::unlock_connector_customer_status(
state,
&connector_customer_id,
&payment_intent.id
)
.await;
let payments_response = psync_response
.clone()
.generate_response(state, None, None, None, &platform, profile, None)
.change_context(errors::RecoveryError::PaymentsResponseGenerationFailed)
.attach_printable("Failed while generating response for payment")?;
RevenueRecoveryOutgoingWebhook::send_outgoing_webhook_based_on_revenue_recovery_status(
state,
common_enums::EventClass::Payments,
event_status,
payment_intent,
&platform,
profile,
recovery_payment_attempt
.attempt_id
.get_string_repr()
.to_string(),
payments_response
)
.await?;
// Record a successful transaction back to Billing Connector
// TODO: Add support for retrying failed outgoing recordback webhooks
record_back_to_billing_connector(
state,
&payment_attempt,
payment_intent,
&revenue_recovery_payment_data.billing_mca,
)
.await
.change_context(errors::RecoveryError::RecordBackToBillingConnectorFailed)
.attach_printable("Failed to update the process tracker")?;
}
Self::PartialCharged => {
// finish psync task as the payment was a PartialCharged
db.as_scheduler()
.finish_process_with_business_status(
process_tracker.clone(),
business_status::PSYNC_WORKFLOW_COMPLETE,
)
.await?;
// publish events to kafka
recovery_incoming_flow::RecoveryPaymentTuple::publish_revenue_recovery_event_to_kafka(
state,
&recovery_payment_tuple,
Some(retry_count + 1),
)
.await
.inspect_err(|e| {
router_env::logger::error!(
"Failed to publish revenue recovery event to kafka: {:?}",
e
);
})
.ok();
// update the status of token in redis
let _update_error_code = storage::revenue_recovery_redis_operation::RedisTokenManager::update_payment_processor_token_error_code_from_process_tracker(
state,
&connector_customer_id,
&None,
&None,
used_token.as_deref(),
)
.await;
let payments_response = psync_response
.clone()
.generate_response(state, None, None, None, &platform, profile, None)
.change_context(errors::RecoveryError::PaymentsResponseGenerationFailed)
.attach_printable("Failed while generating response for payment")?;
Box::pin(reopen_calculate_workflow_on_payment_failure(
state,
&process_tracker.clone(),
profile,
platform.clone(),
payment_intent,
revenue_recovery_payment_data,
psync_response.payment_attempt.get_id(),
))
.await?;
RevenueRecoveryOutgoingWebhook::send_outgoing_webhook_based_on_revenue_recovery_status(
state,
common_enums::EventClass::Payments,
event_status,
payment_intent,
&platform,
profile,
recovery_payment_attempt
.attempt_id
.get_string_repr()
.to_string(),
payments_response
)
.await?;
}
Self::Failed => {
// finish psync task
db.as_scheduler()
.finish_process_with_business_status(
process_tracker.clone(),
business_status::PSYNC_WORKFLOW_COMPLETE,
)
.await?;
// publish events to kafka
if let Err(e) = recovery_incoming_flow::RecoveryPaymentTuple::publish_revenue_recovery_event_to_kafka(
state,
&recovery_payment_tuple,
Some(retry_count+1)
)
.await{
router_env::logger::error!(
"Failed to publish revenue recovery event to kafka : {:?}", e
);
};
let error_code = recovery_payment_attempt.error_code;
let is_hard_decline = revenue_recovery::check_hard_decline(state, &payment_attempt)
.await
.ok();
// update the status of token in redis
let _update_error_code = storage::revenue_recovery_redis_operation::RedisTokenManager::update_payment_processor_token_error_code_from_process_tracker(
state,
&connector_customer_id,
&error_code,
&is_hard_decline,
used_token.as_deref(),
)
.await;
// unlocking the token
let _unlock_the_connector_customer_id = storage::revenue_recovery_redis_operation::RedisTokenManager::unlock_connector_customer_status(
state,
&connector_customer_id,
&payment_intent.id
)
.await;
// Reopen calculate workflow on payment failure
Box::pin(reopen_calculate_workflow_on_payment_failure(
state,
&process_tracker,
profile,
platform,
payment_intent,
revenue_recovery_payment_data,
psync_response.payment_attempt.get_id(),
))
.await?;
}
Self::Processing => {
// do a psync payment
let action = Box::pin(Action::payment_sync_call(
state,
revenue_recovery_payment_data,
payment_intent,
&process_tracker,
profile,
platform,
payment_attempt,
))
.await?;
//handle the response
Box::pin(action.psync_response_handler(
state,
payment_intent,
&process_tracker,
revenue_recovery_metadata,
revenue_recovery_payment_data,
))
.await?;
}
Self::InvalidStatus(status) => logger::debug!(
"Invalid Attempt Status for the Recovery Payment : {}",
status
),
}
Ok(())
}
}
pub enum Decision {
Execute,
Psync(enums::IntentStatus, id_type::GlobalAttemptId),
InvalidDecision,
ReviewForSuccessfulPayment,
ReviewForFailedPayment(enums::TriggeredBy),
}
impl Decision {
pub async fn get_decision_based_on_params(
state: &SessionState,
intent_status: enums::IntentStatus,
called_connector: enums::PaymentConnectorTransmission,
active_attempt_id: Option<&id_type::GlobalAttemptId>,
revenue_recovery_data: &storage::revenue_recovery::RevenueRecoveryPaymentData,
payment_id: &id_type::GlobalPaymentId,
) -> RecoveryResult<Self> {
logger::info!("Entering get_decision_based_on_params");
Ok(match (intent_status, called_connector, active_attempt_id) {
(
enums::IntentStatus::Failed,
enums::PaymentConnectorTransmission::ConnectorCallUnsuccessful,
None,
) => Self::Execute,
(
enums::IntentStatus::PartiallyCaptured,
enums::PaymentConnectorTransmission::ConnectorCallSucceeded,
Some(_),
) => Self::Execute,
(
enums::IntentStatus::Processing,
enums::PaymentConnectorTransmission::ConnectorCallSucceeded,
Some(_),
) => {
let psync_data = revenue_recovery_core::api::call_psync_api(
state,
payment_id,
revenue_recovery_data,
true,
true,
)
.await
.change_context(errors::RecoveryError::PaymentCallFailed)
.attach_printable("Error while executing the Psync call")?;
let payment_attempt = psync_data.payment_attempt;
let payment_intent = psync_data.payment_intent;
Self::Psync(payment_intent.status, payment_attempt.get_id().clone())
}
(
enums::IntentStatus::PartiallyCapturedAndProcessing,
enums::PaymentConnectorTransmission::ConnectorCallSucceeded,
Some(_),
) => {
let psync_data = revenue_recovery_core::api::call_psync_api(
state,
payment_id,
revenue_recovery_data,
true,
true,
)
.await
.change_context(errors::RecoveryError::PaymentCallFailed)
.attach_printable("Error while executing the Psync call")?;
let payment_attempt = psync_data.payment_attempt;
let payment_intent = psync_data.payment_intent;
Self::Psync(payment_intent.status, payment_attempt.get_id().clone())
}
(
enums::IntentStatus::Failed,
enums::PaymentConnectorTransmission::ConnectorCallUnsuccessful,
Some(_),
) => {
let psync_data = revenue_recovery_core::api::call_psync_api(
state,
payment_id,
revenue_recovery_data,
true,
true,
)
.await
.change_context(errors::RecoveryError::PaymentCallFailed)
.attach_printable("Error while executing the Psync call")?;
let payment_attempt = psync_data.payment_attempt;
let attempt_triggered_by = payment_attempt
.feature_metadata
.and_then(|metadata| {
metadata.revenue_recovery.map(|revenue_recovery_metadata| {
revenue_recovery_metadata.attempt_triggered_by
})
})
.get_required_value("Attempt Triggered By")
.change_context(errors::RecoveryError::ValueNotFound)?;
Self::ReviewForFailedPayment(attempt_triggered_by)
}
(enums::IntentStatus::Succeeded, _, _) => Self::ReviewForSuccessfulPayment,
_ => Self::InvalidDecision,
})
}
}
#[derive(Debug, Clone)]
pub enum Action {
SyncPayment(PaymentAttempt),
RetryPayment(PrimitiveDateTime),
TerminalFailure(PaymentAttempt),
SuccessfulPayment(PaymentAttempt),
PartialCharged,
ReviewPayment,
ManualReviewAction,
}
impl Action {
#[allow(clippy::too_many_arguments)]
pub async fn execute_payment(
state: &SessionState,
_merchant_id: &id_type::MerchantId,
payment_intent: &PaymentIntent,
process: &storage::ProcessTracker,
profile: &domain::Profile,
platform: domain::Platform,
revenue_recovery_payment_data: &storage::revenue_recovery::RevenueRecoveryPaymentData,
revenue_recovery_metadata: &PaymentRevenueRecoveryMetadata,
latest_attempt_id: &id_type::GlobalAttemptId,
scheduled_token: &storage::revenue_recovery_redis_operation::PaymentProcessorTokenStatus,
) -> RecoveryResult<Self> {
let connector_customer_id = payment_intent
.extract_connector_customer_id_from_payment_intent()
.change_context(errors::RecoveryError::ValueNotFound)
.attach_printable("Failed to extract customer ID from payment intent")?;
let response = revenue_recovery_core::api::call_proxy_api(
state,
payment_intent,
revenue_recovery_payment_data,
revenue_recovery_metadata,
&scheduled_token
.payment_processor_token_details
.payment_processor_token,
)
.await;
let recovery_payment_intent =
hyperswitch_domain_models::revenue_recovery::RecoveryPaymentIntent::from(
payment_intent,
);
let intent_status = recovery_payment_intent.status;
// handle proxy api's response
match response {
Ok(payment_data) => {
let account_updater_action = storage::revenue_recovery_redis_operation::RedisTokenManager::handle_account_updater_token_update(
state,
&connector_customer_id,
scheduled_token,
payment_data.mandate_data.clone(),
&payment_data.payment_attempt.id
).await
.inspect_err(|e| {
logger::error!(
"Failed to handle get valid action: {:?}",
e
);
})
.ok();
let _account_updater_result = account_updater_action
.async_map(|action| {
let customer_id = connector_customer_id.clone();
let payment_attempt_id = payment_data.payment_attempt.id.clone();
async move {
action
.handle_account_updater_action(
state,
customer_id.as_str(),
scheduled_token,
&payment_attempt_id,
)
.await
}
})
.await
.transpose()
.inspect_err(|e| {
logger::error!("Failed to handle account updater action: {:?}", e);
})
.ok();
let intent_status: RevenueRecoveryPaymentIntentStatus =
payment_data.payment_intent.status.foreign_into();
let event_status = common_enums::EventType::from(intent_status.clone());
match intent_status {
RevenueRecoveryPaymentIntentStatus::Succeeded => {
let recovery_payment_attempt =
hyperswitch_domain_models::revenue_recovery::RecoveryPaymentAttempt::from(
&payment_data.payment_attempt,
);
let recovery_payment_tuple =
recovery_incoming_flow::RecoveryPaymentTuple::new(
&recovery_payment_intent,
&recovery_payment_attempt,
);
// publish events to kafka
if let Err(e) = recovery_incoming_flow::RecoveryPaymentTuple::publish_revenue_recovery_event_to_kafka(
state,
&recovery_payment_tuple,
Some(process.retry_count+1)
)
.await{
router_env::logger::error!(
"Failed to publish revenue recovery event to kafka: {:?}",
e
);
};
// update the status of token in redis
let _update_error_code = storage::revenue_recovery_redis_operation::RedisTokenManager::update_payment_processor_token_error_code_from_process_tracker(
state,
&connector_customer_id,
&None,
&None,
Some(&scheduled_token.payment_processor_token_details.payment_processor_token),
)
.await;
// unlocking the token
storage::revenue_recovery_redis_operation::RedisTokenManager::unlock_connector_customer_status(
state,
&connector_customer_id,
&payment_intent.id
)
.await;
let payments_response = payment_data
.clone()
.generate_response(state, None, None, None, &platform, profile, None)
.change_context(errors::RecoveryError::PaymentsResponseGenerationFailed)
.attach_printable("Failed while generating response for payment")?;
RevenueRecoveryOutgoingWebhook::send_outgoing_webhook_based_on_revenue_recovery_status(
state,
common_enums::EventClass::Payments,
event_status,
payment_intent,
&platform,
profile,
payment_data.payment_attempt.id.get_string_repr().to_string(),
payments_response
)
.await?;
Ok(Self::SuccessfulPayment(
payment_data.payment_attempt.clone(),
))
}
RevenueRecoveryPaymentIntentStatus::PartialCharged => {
let recovery_payment_attempt =
hyperswitch_domain_models::revenue_recovery::RecoveryPaymentAttempt::from(
&payment_data.payment_attempt,
);
let recovery_payment_tuple =
recovery_incoming_flow::RecoveryPaymentTuple::new(
&recovery_payment_intent,
&recovery_payment_attempt,
);
// update the status of token in redis
let _update_error_code = storage::revenue_recovery_redis_operation::RedisTokenManager::update_payment_processor_token_error_code_from_process_tracker(
state,
&connector_customer_id,
&None,
&None,
Some(&scheduled_token.payment_processor_token_details.payment_processor_token),
)
.await;
let payments_response = payment_data
.clone()
.generate_response(state, None, None, None, &platform, profile, None)
.change_context(errors::RecoveryError::PaymentsResponseGenerationFailed)
.attach_printable("Failed while generating response for payment")?;
RevenueRecoveryOutgoingWebhook::send_outgoing_webhook_based_on_revenue_recovery_status(
state,
common_enums::EventClass::Payments,
event_status,
payment_intent,
&platform,
profile,
payment_data.payment_attempt.id.get_string_repr().to_string(),
payments_response
)
.await?;
Ok(Self::PartialCharged)
}
RevenueRecoveryPaymentIntentStatus::Failed => {
let recovery_payment_attempt =
hyperswitch_domain_models::revenue_recovery::RecoveryPaymentAttempt::from(
&payment_data.payment_attempt,
);
let recovery_payment_tuple =
recovery_incoming_flow::RecoveryPaymentTuple::new(
&recovery_payment_intent,
&recovery_payment_attempt,
);
// publish events to kafka
if let Err(e) = recovery_incoming_flow::RecoveryPaymentTuple::publish_revenue_recovery_event_to_kafka(
state,
&recovery_payment_tuple,
Some(process.retry_count+1)
)
.await{
router_env::logger::error!(
"Failed to publish revenue recovery event to kafka: {:?}",
e
);
};
let error_code = payment_data
.payment_attempt
.clone()
.error
.map(|error| error.code);
let is_hard_decline = revenue_recovery::check_hard_decline(
state,
&payment_data.payment_attempt,
)
.await
.ok();
let _update_connector_customer_id = storage::revenue_recovery_redis_operation::RedisTokenManager::update_payment_processor_token_error_code_from_process_tracker(
state,
&connector_customer_id,
&error_code,
&is_hard_decline,
Some(&scheduled_token
.payment_processor_token_details
.payment_processor_token)
,
)
.await;
// unlocking the token
storage::revenue_recovery_redis_operation::RedisTokenManager::unlock_connector_customer_status(
state,
&connector_customer_id,
&payment_intent.id
)
.await;
// Reopen calculate workflow on payment failure
Box::pin(reopen_calculate_workflow_on_payment_failure(
state,
process,
profile,
platform,
payment_intent,
revenue_recovery_payment_data,
latest_attempt_id,
))
.await?;
// Return terminal failure to finish the current execute workflow
Ok(Self::TerminalFailure(payment_data.payment_attempt.clone()))
}
RevenueRecoveryPaymentIntentStatus::Processing => {
Ok(Self::SyncPayment(payment_data.payment_attempt.clone()))
}
RevenueRecoveryPaymentIntentStatus::InvalidStatus(action) => {
logger::info!(?action, "Invalid Payment Status For PCR Payment");
Ok(Self::ManualReviewAction)
}
}
}
Err(err) =>
// check for an active attempt being constructed or not
{
logger::error!(execute_payment_res=?err);
Ok(Self::ReviewPayment)
}
}
}
pub async fn execute_payment_task_response_handler(
&self,
state: &SessionState,
payment_intent: &PaymentIntent,
execute_task_process: &storage::ProcessTracker,
revenue_recovery_payment_data: &storage::revenue_recovery::RevenueRecoveryPaymentData,
revenue_recovery_metadata: &mut PaymentRevenueRecoveryMetadata,
) -> Result<(), errors::ProcessTrackerError> {
logger::info!("Entering execute_payment_task_response_handler");
let db = &*state.store;
match self {
Self::SyncPayment(payment_attempt) => {
revenue_recovery_core::insert_psync_pcr_task_to_pt(
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | true |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/revenue_recovery/transformers.rs | crates/router/src/core/revenue_recovery/transformers.rs | use common_enums::IntentStatus;
use masking::PeekInterface;
use crate::{
core::revenue_recovery::types::RevenueRecoveryPaymentIntentStatus,
types::transformers::ForeignFrom,
};
impl ForeignFrom<IntentStatus> for RevenueRecoveryPaymentIntentStatus {
fn foreign_from(status: IntentStatus) -> Self {
match status {
IntentStatus::Succeeded => Self::Succeeded,
IntentStatus::PartiallyCapturedAndProcessing | IntentStatus::Processing => {
Self::Processing
}
IntentStatus::Failed => Self::Failed,
IntentStatus::PartiallyCaptured | IntentStatus::PartiallyCapturedAndCapturable => {
Self::PartialCharged
}
IntentStatus::Cancelled
| IntentStatus::CancelledPostCapture
| IntentStatus::RequiresCustomerAction
| IntentStatus::RequiresMerchantAction
| IntentStatus::RequiresPaymentMethod
| IntentStatus::RequiresConfirmation
| IntentStatus::RequiresCapture
| IntentStatus::PartiallyAuthorizedAndRequiresCapture
| IntentStatus::Conflicted
| IntentStatus::Expired => Self::InvalidStatus(status.to_string()),
}
}
}
impl From<RevenueRecoveryPaymentIntentStatus> for common_enums::EventType {
fn from(status: RevenueRecoveryPaymentIntentStatus) -> Self {
match status {
RevenueRecoveryPaymentIntentStatus::Succeeded => Self::PaymentSucceeded,
RevenueRecoveryPaymentIntentStatus::PartialCharged => Self::PaymentCaptured,
RevenueRecoveryPaymentIntentStatus::Processing => Self::PaymentProcessing,
RevenueRecoveryPaymentIntentStatus::Failed => Self::PaymentFailed,
RevenueRecoveryPaymentIntentStatus::InvalidStatus(_) => Self::ActionRequired,
}
}
}
impl ForeignFrom<api_models::payments::RecoveryPaymentsCreate>
for hyperswitch_domain_models::revenue_recovery::RevenueRecoveryInvoiceData
{
fn foreign_from(data: api_models::payments::RecoveryPaymentsCreate) -> Self {
Self {
amount: data.amount_details.order_amount().into(),
currency: data.amount_details.currency(),
merchant_reference_id: data.merchant_reference_id,
billing_address: data.billing,
retry_count: None,
next_billing_at: None,
billing_started_at: data.billing_started_at,
metadata: data.metadata,
enable_partial_authorization: data.enable_partial_authorization,
}
}
}
impl ForeignFrom<&api_models::payments::RecoveryPaymentsCreate>
for hyperswitch_domain_models::revenue_recovery::RevenueRecoveryAttemptData
{
fn foreign_from(data: &api_models::payments::RecoveryPaymentsCreate) -> Self {
Self {
amount: data.amount_details.order_amount().into(),
currency: data.amount_details.currency(),
merchant_reference_id: data.merchant_reference_id.to_owned(),
connector_transaction_id: data.connector_transaction_id.as_ref().map(|txn_id| {
common_utils::types::ConnectorTransactionId::TxnId(txn_id.peek().to_string())
}),
error_code: data.error.as_ref().map(|error| error.code.clone()),
error_message: data.error.as_ref().map(|error| error.message.clone()),
processor_payment_method_token: data
.payment_method_data
.primary_processor_payment_method_token
.peek()
.to_string(),
connector_customer_id: data.connector_customer_id.peek().to_string(),
connector_account_reference_id: data
.payment_merchant_connector_id
.get_string_repr()
.to_string(),
transaction_created_at: data.transaction_created_at.to_owned(),
status: data.attempt_status,
payment_method_type: data.payment_method_type,
payment_method_sub_type: data.payment_method_sub_type,
network_advice_code: data
.error
.as_ref()
.and_then(|error| error.network_advice_code.clone()),
network_decline_code: data
.error
.as_ref()
.and_then(|error| error.network_decline_code.clone()),
network_error_message: data
.error
.as_ref()
.and_then(|error| error.network_error_message.clone()),
// retry count will be updated whenever there is new attempt is created.
retry_count: None,
invoice_next_billing_time: None,
invoice_billing_started_at_time: data.billing_started_at,
card_info: data
.payment_method_data
.additional_payment_method_info
.clone(),
charge_id: None,
}
}
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/payment_methods/vault.rs | crates/router/src/core/payment_methods/vault.rs | use common_enums::PaymentMethodType;
#[cfg(feature = "v2")]
use common_utils::request;
use common_utils::{
crypto::{DecodeMessage, EncodeMessage, GcmAes256},
ext_traits::{BytesExt, Encode},
generate_id_with_default_len, id_type,
pii::Email,
};
use error_stack::{report, ResultExt};
#[cfg(feature = "v2")]
use hyperswitch_domain_models::router_flow_types::{
ExternalVaultDeleteFlow, ExternalVaultRetrieveFlow,
};
use hyperswitch_domain_models::{
router_data_v2::flow_common_types::VaultConnectorFlowData, types::VaultRouterData,
};
use masking::PeekInterface;
use router_env::{instrument, tracing};
use scheduler::{types::process_data, utils as process_tracker_utils};
#[cfg(feature = "payouts")]
use crate::types::api::payouts;
use crate::{
consts,
core::{
errors::{self, ConnectorErrorExt, CustomResult, RouterResult},
payments, utils as core_utils,
},
db, logger,
routes::{self, metrics},
services::{self, connector_integration_interface::RouterDataConversion},
types::{
self, api, domain,
storage::{self, enums},
},
utils::StringExt,
};
#[cfg(feature = "v2")]
use crate::{
core::{
errors::StorageErrorExt,
payment_methods::{transformers as pm_transforms, utils},
payments::{self as payments_core, helpers as payment_helpers},
},
headers, settings,
types::payment_methods as pm_types,
utils::{ext_traits::OptionExt, ConnectorResponseExt},
};
const VAULT_SERVICE_NAME: &str = "CARD";
pub struct SupplementaryVaultData {
pub customer_id: Option<id_type::CustomerId>,
pub payment_method_id: Option<String>,
}
pub trait Vaultable: Sized {
fn get_value1(
&self,
customer_id: Option<id_type::CustomerId>,
) -> CustomResult<String, errors::VaultError>;
fn get_value2(
&self,
_customer_id: Option<id_type::CustomerId>,
) -> CustomResult<String, errors::VaultError> {
Ok(String::new())
}
fn from_values(
value1: String,
value2: String,
) -> CustomResult<(Self, SupplementaryVaultData), errors::VaultError>;
}
impl Vaultable for domain::Card {
fn get_value1(
&self,
_customer_id: Option<id_type::CustomerId>,
) -> CustomResult<String, errors::VaultError> {
let value1 = domain::TokenizedCardValue1 {
card_number: self.card_number.peek().clone(),
exp_year: self.card_exp_year.peek().clone(),
exp_month: self.card_exp_month.peek().clone(),
nickname: self.nick_name.as_ref().map(|name| name.peek().clone()),
card_last_four: None,
card_token: None,
card_holder_name: self.card_holder_name.clone(),
};
value1
.encode_to_string_of_json()
.change_context(errors::VaultError::RequestEncodingFailed)
.attach_printable("Failed to encode card value1")
}
fn get_value2(
&self,
customer_id: Option<id_type::CustomerId>,
) -> CustomResult<String, errors::VaultError> {
let value2 = domain::TokenizedCardValue2 {
card_security_code: Some(self.card_cvc.peek().clone()),
card_fingerprint: None,
external_id: None,
customer_id,
payment_method_id: None,
};
value2
.encode_to_string_of_json()
.change_context(errors::VaultError::RequestEncodingFailed)
.attach_printable("Failed to encode card value2")
}
fn from_values(
value1: String,
value2: String,
) -> CustomResult<(Self, SupplementaryVaultData), errors::VaultError> {
let value1: domain::TokenizedCardValue1 = value1
.parse_struct("TokenizedCardValue1")
.change_context(errors::VaultError::ResponseDeserializationFailed)
.attach_printable("Could not deserialize into card value1")?;
let value2: domain::TokenizedCardValue2 = value2
.parse_struct("TokenizedCardValue2")
.change_context(errors::VaultError::ResponseDeserializationFailed)
.attach_printable("Could not deserialize into card value2")?;
let card = Self {
card_number: cards::CardNumber::try_from(value1.card_number)
.change_context(errors::VaultError::ResponseDeserializationFailed)
.attach_printable("Invalid card number format from the mock locker")?,
card_exp_month: value1.exp_month.into(),
card_exp_year: value1.exp_year.into(),
card_cvc: value2.card_security_code.unwrap_or_default().into(),
card_issuer: None,
card_network: None,
bank_code: None,
card_issuing_country: None,
card_issuing_country_code: None,
card_type: None,
nick_name: value1.nickname.map(masking::Secret::new),
card_holder_name: value1.card_holder_name,
co_badged_card_data: None,
};
let supp_data = SupplementaryVaultData {
customer_id: value2.customer_id,
payment_method_id: value2.payment_method_id,
};
Ok((card, supp_data))
}
}
impl Vaultable for domain::BankTransferData {
fn get_value1(
&self,
_customer_id: Option<id_type::CustomerId>,
) -> CustomResult<String, errors::VaultError> {
let value1 = domain::TokenizedBankTransferValue1 {
data: self.to_owned(),
};
value1
.encode_to_string_of_json()
.change_context(errors::VaultError::RequestEncodingFailed)
.attach_printable("Failed to encode bank transfer data")
}
fn get_value2(
&self,
customer_id: Option<id_type::CustomerId>,
) -> CustomResult<String, errors::VaultError> {
let value2 = domain::TokenizedBankTransferValue2 { customer_id };
value2
.encode_to_string_of_json()
.change_context(errors::VaultError::RequestEncodingFailed)
.attach_printable("Failed to encode bank transfer supplementary data")
}
fn from_values(
value1: String,
value2: String,
) -> CustomResult<(Self, SupplementaryVaultData), errors::VaultError> {
let value1: domain::TokenizedBankTransferValue1 = value1
.parse_struct("TokenizedBankTransferValue1")
.change_context(errors::VaultError::ResponseDeserializationFailed)
.attach_printable("Could not deserialize into bank transfer data")?;
let value2: domain::TokenizedBankTransferValue2 = value2
.parse_struct("TokenizedBankTransferValue2")
.change_context(errors::VaultError::ResponseDeserializationFailed)
.attach_printable("Could not deserialize into supplementary bank transfer data")?;
let bank_transfer_data = value1.data;
let supp_data = SupplementaryVaultData {
customer_id: value2.customer_id,
payment_method_id: None,
};
Ok((bank_transfer_data, supp_data))
}
}
impl Vaultable for domain::WalletData {
fn get_value1(
&self,
_customer_id: Option<id_type::CustomerId>,
) -> CustomResult<String, errors::VaultError> {
let value1 = domain::TokenizedWalletValue1 {
data: self.to_owned(),
};
value1
.encode_to_string_of_json()
.change_context(errors::VaultError::RequestEncodingFailed)
.attach_printable("Failed to encode wallet data value1")
}
fn get_value2(
&self,
customer_id: Option<id_type::CustomerId>,
) -> CustomResult<String, errors::VaultError> {
let value2 = domain::TokenizedWalletValue2 { customer_id };
value2
.encode_to_string_of_json()
.change_context(errors::VaultError::RequestEncodingFailed)
.attach_printable("Failed to encode wallet data value2")
}
fn from_values(
value1: String,
value2: String,
) -> CustomResult<(Self, SupplementaryVaultData), errors::VaultError> {
let value1: domain::TokenizedWalletValue1 = value1
.parse_struct("TokenizedWalletValue1")
.change_context(errors::VaultError::ResponseDeserializationFailed)
.attach_printable("Could not deserialize into wallet data value1")?;
let value2: domain::TokenizedWalletValue2 = value2
.parse_struct("TokenizedWalletValue2")
.change_context(errors::VaultError::ResponseDeserializationFailed)
.attach_printable("Could not deserialize into wallet data value2")?;
let wallet = value1.data;
let supp_data = SupplementaryVaultData {
customer_id: value2.customer_id,
payment_method_id: None,
};
Ok((wallet, supp_data))
}
}
impl Vaultable for domain::BankRedirectData {
fn get_value1(
&self,
_customer_id: Option<id_type::CustomerId>,
) -> CustomResult<String, errors::VaultError> {
let value1 = domain::TokenizedBankRedirectValue1 {
data: self.to_owned(),
};
value1
.encode_to_string_of_json()
.change_context(errors::VaultError::RequestEncodingFailed)
.attach_printable("Failed to encode bank redirect data")
}
fn get_value2(
&self,
customer_id: Option<id_type::CustomerId>,
) -> CustomResult<String, errors::VaultError> {
let value2 = domain::TokenizedBankRedirectValue2 { customer_id };
value2
.encode_to_string_of_json()
.change_context(errors::VaultError::RequestEncodingFailed)
.attach_printable("Failed to encode bank redirect supplementary data")
}
fn from_values(
value1: String,
value2: String,
) -> CustomResult<(Self, SupplementaryVaultData), errors::VaultError> {
let value1: domain::TokenizedBankRedirectValue1 = value1
.parse_struct("TokenizedBankRedirectValue1")
.change_context(errors::VaultError::ResponseDeserializationFailed)
.attach_printable("Could not deserialize into bank redirect data")?;
let value2: domain::TokenizedBankRedirectValue2 = value2
.parse_struct("TokenizedBankRedirectValue2")
.change_context(errors::VaultError::ResponseDeserializationFailed)
.attach_printable("Could not deserialize into supplementary bank redirect data")?;
let bank_transfer_data = value1.data;
let supp_data = SupplementaryVaultData {
customer_id: value2.customer_id,
payment_method_id: None,
};
Ok((bank_transfer_data, supp_data))
}
}
impl Vaultable for domain::BankDebitData {
fn get_value1(
&self,
_customer_id: Option<id_type::CustomerId>,
) -> CustomResult<String, errors::VaultError> {
let value1 = domain::TokenizedBankDebitValue1 {
data: self.to_owned(),
};
value1
.encode_to_string_of_json()
.change_context(errors::VaultError::RequestEncodingFailed)
.attach_printable("Failed to encode bank debit data")
}
fn get_value2(
&self,
customer_id: Option<id_type::CustomerId>,
) -> CustomResult<String, errors::VaultError> {
let value2 = domain::TokenizedBankDebitValue2 { customer_id };
value2
.encode_to_string_of_json()
.change_context(errors::VaultError::RequestEncodingFailed)
.attach_printable("Failed to encode bank debit supplementary data")
}
fn from_values(
value1: String,
value2: String,
) -> CustomResult<(Self, SupplementaryVaultData), errors::VaultError> {
let value1: domain::TokenizedBankDebitValue1 = value1
.parse_struct("TokenizedBankDebitValue1")
.change_context(errors::VaultError::ResponseDeserializationFailed)
.attach_printable("Could not deserialize into bank debit data")?;
let value2: domain::TokenizedBankDebitValue2 = value2
.parse_struct("TokenizedBankDebitValue2")
.change_context(errors::VaultError::ResponseDeserializationFailed)
.attach_printable("Could not deserialize into supplementary bank debit data")?;
let bank_transfer_data = value1.data;
let supp_data = SupplementaryVaultData {
customer_id: value2.customer_id,
payment_method_id: None,
};
Ok((bank_transfer_data, supp_data))
}
}
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
#[serde(tag = "type", content = "value", rename_all = "snake_case")]
pub enum VaultPaymentMethod {
Card(String),
Wallet(String),
BankTransfer(String),
BankRedirect(String),
BankDebit(String),
}
impl Vaultable for domain::PaymentMethodData {
fn get_value1(
&self,
customer_id: Option<id_type::CustomerId>,
) -> CustomResult<String, errors::VaultError> {
let value1 = match self {
Self::Card(card) => VaultPaymentMethod::Card(card.get_value1(customer_id)?),
Self::Wallet(wallet) => VaultPaymentMethod::Wallet(wallet.get_value1(customer_id)?),
Self::BankTransfer(bank_transfer) => {
VaultPaymentMethod::BankTransfer(bank_transfer.get_value1(customer_id)?)
}
Self::BankRedirect(bank_redirect) => {
VaultPaymentMethod::BankRedirect(bank_redirect.get_value1(customer_id)?)
}
Self::BankDebit(bank_debit) => {
VaultPaymentMethod::BankDebit(bank_debit.get_value1(customer_id)?)
}
_ => Err(errors::VaultError::PaymentMethodNotSupported)
.attach_printable("Payment method not supported")?,
};
value1
.encode_to_string_of_json()
.change_context(errors::VaultError::RequestEncodingFailed)
.attach_printable("Failed to encode payment method value1")
}
fn get_value2(
&self,
customer_id: Option<id_type::CustomerId>,
) -> CustomResult<String, errors::VaultError> {
let value2 = match self {
Self::Card(card) => VaultPaymentMethod::Card(card.get_value2(customer_id)?),
Self::Wallet(wallet) => VaultPaymentMethod::Wallet(wallet.get_value2(customer_id)?),
Self::BankTransfer(bank_transfer) => {
VaultPaymentMethod::BankTransfer(bank_transfer.get_value2(customer_id)?)
}
Self::BankRedirect(bank_redirect) => {
VaultPaymentMethod::BankRedirect(bank_redirect.get_value2(customer_id)?)
}
Self::BankDebit(bank_debit) => {
VaultPaymentMethod::BankDebit(bank_debit.get_value2(customer_id)?)
}
_ => Err(errors::VaultError::PaymentMethodNotSupported)
.attach_printable("Payment method not supported")?,
};
value2
.encode_to_string_of_json()
.change_context(errors::VaultError::RequestEncodingFailed)
.attach_printable("Failed to encode payment method value2")
}
fn from_values(
value1: String,
value2: String,
) -> CustomResult<(Self, SupplementaryVaultData), errors::VaultError> {
let value1: VaultPaymentMethod = value1
.parse_struct("PaymentMethodValue1")
.change_context(errors::VaultError::ResponseDeserializationFailed)
.attach_printable("Could not deserialize into payment method value 1")?;
let value2: VaultPaymentMethod = value2
.parse_struct("PaymentMethodValue2")
.change_context(errors::VaultError::ResponseDeserializationFailed)
.attach_printable("Could not deserialize into payment method value 2")?;
match (value1, value2) {
(VaultPaymentMethod::Card(mvalue1), VaultPaymentMethod::Card(mvalue2)) => {
let (card, supp_data) = domain::Card::from_values(mvalue1, mvalue2)?;
Ok((Self::Card(card), supp_data))
}
(VaultPaymentMethod::Wallet(mvalue1), VaultPaymentMethod::Wallet(mvalue2)) => {
let (wallet, supp_data) = domain::WalletData::from_values(mvalue1, mvalue2)?;
Ok((Self::Wallet(wallet), supp_data))
}
(
VaultPaymentMethod::BankTransfer(mvalue1),
VaultPaymentMethod::BankTransfer(mvalue2),
) => {
let (bank_transfer, supp_data) =
domain::BankTransferData::from_values(mvalue1, mvalue2)?;
Ok((Self::BankTransfer(Box::new(bank_transfer)), supp_data))
}
(
VaultPaymentMethod::BankRedirect(mvalue1),
VaultPaymentMethod::BankRedirect(mvalue2),
) => {
let (bank_redirect, supp_data) =
domain::BankRedirectData::from_values(mvalue1, mvalue2)?;
Ok((Self::BankRedirect(bank_redirect), supp_data))
}
(VaultPaymentMethod::BankDebit(mvalue1), VaultPaymentMethod::BankDebit(mvalue2)) => {
let (bank_debit, supp_data) = domain::BankDebitData::from_values(mvalue1, mvalue2)?;
Ok((Self::BankDebit(bank_debit), supp_data))
}
_ => Err(errors::VaultError::PaymentMethodNotSupported)
.attach_printable("Payment method not supported"),
}
}
}
#[cfg(feature = "payouts")]
impl Vaultable for api::CardPayout {
fn get_value1(
&self,
_customer_id: Option<id_type::CustomerId>,
) -> CustomResult<String, errors::VaultError> {
let value1 = api::TokenizedCardValue1 {
card_number: self.card_number.peek().clone(),
exp_year: self.expiry_year.peek().clone(),
exp_month: self.expiry_month.peek().clone(),
name_on_card: self.card_holder_name.clone().map(|n| n.peek().to_string()),
nickname: None,
card_last_four: None,
card_token: None,
card_network: self.card_network.clone(),
};
value1
.encode_to_string_of_json()
.change_context(errors::VaultError::RequestEncodingFailed)
.attach_printable("Failed to encode card value1")
}
fn get_value2(
&self,
customer_id: Option<id_type::CustomerId>,
) -> CustomResult<String, errors::VaultError> {
let value2 = api::TokenizedCardValue2 {
card_security_code: None,
card_fingerprint: None,
external_id: None,
customer_id,
payment_method_id: None,
};
value2
.encode_to_string_of_json()
.change_context(errors::VaultError::RequestEncodingFailed)
.attach_printable("Failed to encode card value2")
}
fn from_values(
value1: String,
value2: String,
) -> CustomResult<(Self, SupplementaryVaultData), errors::VaultError> {
let value1: api::TokenizedCardValue1 = value1
.parse_struct("TokenizedCardValue1")
.change_context(errors::VaultError::ResponseDeserializationFailed)
.attach_printable("Could not deserialize into card value1")?;
let value2: api::TokenizedCardValue2 = value2
.parse_struct("TokenizedCardValue2")
.change_context(errors::VaultError::ResponseDeserializationFailed)
.attach_printable("Could not deserialize into card value2")?;
let card = Self {
card_number: value1
.card_number
.parse()
.map_err(|_| errors::VaultError::FetchCardFailed)?,
expiry_month: value1.exp_month.into(),
expiry_year: value1.exp_year.into(),
card_holder_name: value1.name_on_card.map(masking::Secret::new),
card_network: value1.card_network,
};
let supp_data = SupplementaryVaultData {
customer_id: value2.customer_id,
payment_method_id: value2.payment_method_id,
};
Ok((card, supp_data))
}
}
#[derive(Debug, serde::Serialize, serde::Deserialize)]
pub struct TokenizedWalletSensitiveValues {
pub email: Option<Email>,
pub telephone_number: Option<masking::Secret<String>>,
pub wallet_id: Option<masking::Secret<String>>,
pub wallet_type: PaymentMethodType,
pub dpan: Option<cards::CardNumber>,
pub expiry_month: Option<masking::Secret<String>>,
pub expiry_year: Option<masking::Secret<String>>,
pub card_holder_name: Option<masking::Secret<String>>,
}
#[derive(Debug, serde::Serialize, serde::Deserialize)]
pub struct TokenizedWalletInsensitiveValues {
pub customer_id: Option<id_type::CustomerId>,
pub card_network: Option<common_enums::CardNetwork>,
}
#[cfg(feature = "payouts")]
impl Vaultable for api::WalletPayout {
fn get_value1(
&self,
_customer_id: Option<id_type::CustomerId>,
) -> CustomResult<String, errors::VaultError> {
let value1 = match self {
Self::Paypal(paypal_data) => TokenizedWalletSensitiveValues {
email: paypal_data.email.clone(),
telephone_number: paypal_data.telephone_number.clone(),
wallet_id: paypal_data.paypal_id.clone(),
wallet_type: PaymentMethodType::Paypal,
dpan: None,
expiry_month: None,
expiry_year: None,
card_holder_name: None,
},
Self::Venmo(venmo_data) => TokenizedWalletSensitiveValues {
email: None,
telephone_number: venmo_data.telephone_number.clone(),
wallet_id: None,
wallet_type: PaymentMethodType::Venmo,
dpan: None,
expiry_month: None,
expiry_year: None,
card_holder_name: None,
},
Self::ApplePayDecrypt(apple_pay_decrypt_data) => TokenizedWalletSensitiveValues {
email: None,
telephone_number: None,
wallet_id: None,
wallet_type: PaymentMethodType::ApplePay,
dpan: Some(apple_pay_decrypt_data.dpan.clone()),
expiry_month: Some(apple_pay_decrypt_data.expiry_month.clone()),
expiry_year: Some(apple_pay_decrypt_data.expiry_year.clone()),
card_holder_name: apple_pay_decrypt_data.card_holder_name.clone(),
},
};
value1
.encode_to_string_of_json()
.change_context(errors::VaultError::RequestEncodingFailed)
.attach_printable("Failed to encode wallet data - TokenizedWalletSensitiveValues")
}
fn get_value2(
&self,
customer_id: Option<id_type::CustomerId>,
) -> CustomResult<String, errors::VaultError> {
let value2 = match self {
Self::Paypal(_paypal_data) => TokenizedWalletInsensitiveValues {
customer_id,
card_network: None,
},
Self::Venmo(_venmo_data) => TokenizedWalletInsensitiveValues {
customer_id,
card_network: None,
},
Self::ApplePayDecrypt(apple_pay_decrypt_data) => TokenizedWalletInsensitiveValues {
customer_id,
card_network: apple_pay_decrypt_data.card_network.clone(),
},
};
value2
.encode_to_string_of_json()
.change_context(errors::VaultError::RequestEncodingFailed)
.attach_printable("Failed to encode data - TokenizedWalletInsensitiveValues")
}
fn from_values(
value1: String,
value2: String,
) -> CustomResult<(Self, SupplementaryVaultData), errors::VaultError> {
let value1: TokenizedWalletSensitiveValues = value1
.parse_struct("TokenizedWalletSensitiveValues")
.change_context(errors::VaultError::ResponseDeserializationFailed)
.attach_printable("Could not deserialize into wallet data wallet_sensitive_data")?;
let value2: TokenizedWalletInsensitiveValues = value2
.parse_struct("TokenizedWalletInsensitiveValues")
.change_context(errors::VaultError::ResponseDeserializationFailed)
.attach_printable("Could not deserialize into wallet data wallet_insensitive_data")?;
let wallet = match value1.wallet_type {
PaymentMethodType::Paypal => Self::Paypal(api_models::payouts::Paypal {
email: value1.email,
telephone_number: value1.telephone_number,
paypal_id: value1.wallet_id,
}),
PaymentMethodType::Venmo => Self::Venmo(api_models::payouts::Venmo {
telephone_number: value1.telephone_number,
}),
PaymentMethodType::ApplePay => {
match (value1.dpan, value1.expiry_month, value1.expiry_year) {
(Some(dpan), Some(expiry_month), Some(expiry_year)) => {
Self::ApplePayDecrypt(api_models::payouts::ApplePayDecrypt {
dpan,
expiry_month,
expiry_year,
card_holder_name: value1.card_holder_name,
card_network: value2.card_network,
})
}
_ => Err(errors::VaultError::ResponseDeserializationFailed)?,
}
}
_ => Err(errors::VaultError::PayoutMethodNotSupported)?,
};
let supp_data = SupplementaryVaultData {
customer_id: value2.customer_id,
payment_method_id: None,
};
Ok((wallet, supp_data))
}
}
#[derive(Debug, serde::Serialize, serde::Deserialize)]
pub struct TokenizedBankSensitiveValues {
pub bank_account_number: Option<masking::Secret<String>>,
pub bank_routing_number: Option<masking::Secret<String>>,
pub bic: Option<masking::Secret<String>>,
pub bank_sort_code: Option<masking::Secret<String>>,
pub iban: Option<masking::Secret<String>>,
pub pix_key: Option<masking::Secret<String>>,
pub tax_id: Option<masking::Secret<String>>,
}
#[derive(Debug, serde::Serialize, serde::Deserialize)]
pub struct TokenizedBankInsensitiveValues {
pub customer_id: Option<id_type::CustomerId>,
pub bank_name: Option<String>,
pub bank_country_code: Option<api::enums::CountryAlpha2>,
pub bank_city: Option<String>,
pub bank_branch: Option<String>,
}
#[cfg(feature = "payouts")]
impl Vaultable for api::BankPayout {
fn get_value1(
&self,
_customer_id: Option<id_type::CustomerId>,
) -> CustomResult<String, errors::VaultError> {
let bank_sensitive_data = match self {
Self::Ach(b) => TokenizedBankSensitiveValues {
bank_account_number: Some(b.bank_account_number.clone()),
bank_routing_number: Some(b.bank_routing_number.to_owned()),
bic: None,
bank_sort_code: None,
iban: None,
pix_key: None,
tax_id: None,
},
Self::Bacs(b) => TokenizedBankSensitiveValues {
bank_account_number: Some(b.bank_account_number.to_owned()),
bank_routing_number: None,
bic: None,
bank_sort_code: Some(b.bank_sort_code.to_owned()),
iban: None,
pix_key: None,
tax_id: None,
},
Self::Sepa(b) => TokenizedBankSensitiveValues {
bank_account_number: None,
bank_routing_number: None,
bic: b.bic.to_owned(),
bank_sort_code: None,
iban: Some(b.iban.to_owned()),
pix_key: None,
tax_id: None,
},
Self::Pix(bank_details) => TokenizedBankSensitiveValues {
bank_account_number: Some(bank_details.bank_account_number.to_owned()),
bank_routing_number: None,
bic: None,
bank_sort_code: None,
iban: None,
pix_key: Some(bank_details.pix_key.to_owned()),
tax_id: bank_details.tax_id.to_owned(),
},
};
bank_sensitive_data
.encode_to_string_of_json()
.change_context(errors::VaultError::RequestEncodingFailed)
.attach_printable("Failed to encode data - bank_sensitive_data")
}
fn get_value2(
&self,
customer_id: Option<id_type::CustomerId>,
) -> CustomResult<String, errors::VaultError> {
let bank_insensitive_data = match self {
Self::Ach(b) => TokenizedBankInsensitiveValues {
customer_id,
bank_name: b.bank_name.to_owned(),
bank_country_code: b.bank_country_code.to_owned(),
bank_city: b.bank_city.to_owned(),
bank_branch: None,
},
Self::Bacs(b) => TokenizedBankInsensitiveValues {
customer_id,
bank_name: b.bank_name.to_owned(),
bank_country_code: b.bank_country_code.to_owned(),
bank_city: b.bank_city.to_owned(),
bank_branch: None,
},
Self::Sepa(bank_details) => TokenizedBankInsensitiveValues {
customer_id,
bank_name: bank_details.bank_name.to_owned(),
bank_country_code: bank_details.bank_country_code.to_owned(),
bank_city: bank_details.bank_city.to_owned(),
bank_branch: None,
},
Self::Pix(bank_details) => TokenizedBankInsensitiveValues {
customer_id,
bank_name: bank_details.bank_name.to_owned(),
bank_country_code: None,
bank_city: None,
bank_branch: bank_details.bank_branch.to_owned(),
},
};
bank_insensitive_data
.encode_to_string_of_json()
.change_context(errors::VaultError::RequestEncodingFailed)
.attach_printable("Failed to encode wallet data bank_insensitive_data")
}
fn from_values(
bank_sensitive_data: String,
bank_insensitive_data: String,
) -> CustomResult<(Self, SupplementaryVaultData), errors::VaultError> {
let bank_sensitive_data: TokenizedBankSensitiveValues = bank_sensitive_data
.parse_struct("TokenizedBankValue1")
.change_context(errors::VaultError::ResponseDeserializationFailed)
.attach_printable("Could not deserialize into bank data bank_sensitive_data")?;
let bank_insensitive_data: TokenizedBankInsensitiveValues = bank_insensitive_data
.parse_struct("TokenizedBankValue2")
.change_context(errors::VaultError::ResponseDeserializationFailed)
.attach_printable("Could not deserialize into wallet data bank_insensitive_data")?;
let bank = match (
// ACH + BACS + PIX
bank_sensitive_data.bank_account_number.to_owned(),
bank_sensitive_data.bank_routing_number.to_owned(), // ACH
bank_sensitive_data.bank_sort_code.to_owned(), // BACS
// SEPA
bank_sensitive_data.iban.to_owned(),
bank_sensitive_data.bic,
// PIX
bank_sensitive_data.pix_key,
bank_sensitive_data.tax_id,
) {
(Some(ban), Some(brn), None, None, None, None, None) => {
Self::Ach(payouts::AchBankTransfer {
bank_account_number: ban,
bank_routing_number: brn,
bank_name: bank_insensitive_data.bank_name,
bank_country_code: bank_insensitive_data.bank_country_code,
bank_city: bank_insensitive_data.bank_city,
})
}
(Some(ban), None, Some(bsc), None, None, None, None) => {
Self::Bacs(payouts::BacsBankTransfer {
bank_account_number: ban,
bank_sort_code: bsc,
bank_name: bank_insensitive_data.bank_name,
bank_country_code: bank_insensitive_data.bank_country_code,
bank_city: bank_insensitive_data.bank_city,
})
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | true |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/payment_methods/access_token.rs | crates/router/src/core/payment_methods/access_token.rs | use common_utils::ext_traits::AsyncExt;
use error_stack::ResultExt;
use hyperswitch_domain_models::types::VaultRouterData;
use crate::{
consts,
core::{
errors::{self, RouterResult},
payments,
},
routes::{metrics, SessionState},
services,
types::{
self,
api::{self as api_types, ConnectorCommon},
domain,
},
};
pub async fn create_access_token<F: Clone + 'static>(
state: &SessionState,
connector_data: &api_types::ConnectorData,
merchant_account: &domain::MerchantAccount,
router_data: &mut VaultRouterData<F>,
) -> RouterResult<()> {
let connector_access_token =
add_access_token_for_external_vault(state, connector_data, merchant_account, router_data)
.await?;
if connector_access_token.connector_supports_access_token {
match connector_access_token.access_token_result {
Ok(access_token) => {
router_data.access_token = access_token;
}
Err(connector_error) => {
router_data.response = Err(connector_error);
}
}
}
Ok(())
}
pub async fn add_access_token_for_external_vault<F: Clone + 'static>(
state: &SessionState,
connector: &api_types::ConnectorData,
merchant_account: &domain::MerchantAccount,
router_data: &VaultRouterData<F>,
) -> RouterResult<types::AddAccessTokenResult> {
if connector
.connector_name
.supports_access_token_for_external_vault()
{
let merchant_id = merchant_account.get_id();
let store = &*state.store;
let key = common_utils::access_token::get_default_access_token_key(
merchant_id,
connector.connector.id(),
);
let old_access_token = store
.get_access_token(key)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("DB error when accessing the access token")?;
let res = match old_access_token {
Some(access_token) => Ok(Some(access_token)),
None => {
let cloned_router_data = router_data.clone();
let refresh_token_request_data = types::AccessTokenRequestData::try_from(
router_data.connector_auth_type.clone(),
)
.attach_printable(
"Could not create access token request, invalid connector account credentials",
)?;
let refresh_token_response_data: Result<types::AccessToken, types::ErrorResponse> =
Err(types::ErrorResponse::default());
let refresh_token_router_data = payments::helpers::router_data_type_conversion::<
_,
api_types::AccessTokenAuth,
_,
_,
_,
_,
>(
cloned_router_data,
refresh_token_request_data,
refresh_token_response_data,
);
refresh_connector_auth(state, connector, &refresh_token_router_data)
.await?
.async_map(|access_token| async {
//Store the access token in db
let store = &*state.store;
// This error should not be propagated, we don't want payments to fail once we have
// the access token, the next request will create new access token
let key = common_utils::access_token::get_default_access_token_key(
merchant_id,
connector.connector.id(),
);
let _ = store
.set_access_token(key, access_token.clone())
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("DB error when setting the access token");
Some(access_token)
})
.await
}
};
Ok(types::AddAccessTokenResult {
access_token_result: res,
connector_supports_access_token: true,
})
} else {
Ok(types::AddAccessTokenResult {
access_token_result: Err(types::ErrorResponse::default()),
connector_supports_access_token: false,
})
}
}
pub async fn refresh_connector_auth(
state: &SessionState,
connector: &api_types::ConnectorData,
router_data: &types::RouterData<
api_types::AccessTokenAuth,
types::AccessTokenRequestData,
types::AccessToken,
>,
) -> RouterResult<Result<types::AccessToken, types::ErrorResponse>> {
let connector_integration: services::BoxedAccessTokenConnectorIntegrationInterface<
api_types::AccessTokenAuth,
types::AccessTokenRequestData,
types::AccessToken,
> = connector.connector.get_connector_integration();
let access_token_router_data_result = services::execute_connector_processing_step(
state,
connector_integration,
router_data,
payments::CallConnectorAction::Trigger,
None,
None,
)
.await;
let access_token_router_data = match access_token_router_data_result {
Ok(router_data) => Ok(router_data.response),
Err(connector_error) => {
// If we receive a timeout error from the connector, then
// the error has to be handled gracefully by updating the payment status to failed.
// further payment flow will not be continued
if connector_error.current_context().is_connector_timeout() {
let error_response = types::ErrorResponse {
code: consts::REQUEST_TIMEOUT_ERROR_CODE.to_string(),
message: consts::REQUEST_TIMEOUT_ERROR_MESSAGE.to_string(),
reason: Some(consts::REQUEST_TIMEOUT_ERROR_MESSAGE.to_string()),
status_code: 504,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
connector_metadata: None,
};
Ok(Err(error_response))
} else {
Err(connector_error
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Could not refresh access token"))
}
}
}?;
metrics::ACCESS_TOKEN_CREATION.add(
1,
router_env::metric_attributes!(("connector", connector.connector_name.to_string())),
);
Ok(access_token_router_data)
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/payment_methods/network_tokenization.rs | crates/router/src/core/payment_methods/network_tokenization.rs | #[cfg(feature = "v2")]
use std::fmt::Debug;
#[cfg(feature = "v2")]
use std::str::FromStr;
use ::payment_methods::controller::PaymentMethodsController;
use api_models::payment_methods as api_payment_methods;
#[cfg(feature = "v2")]
use cards::{CardNumber, NetworkToken};
use common_utils::{
errors::CustomResult,
ext_traits::{BytesExt, Encode},
id_type,
metrics::utils::record_operation_time,
request::RequestContent,
};
#[cfg(feature = "v1")]
use error_stack::ResultExt;
#[cfg(feature = "v2")]
use error_stack::{report, ResultExt};
#[cfg(feature = "v2")]
use hyperswitch_domain_models::payment_method_data::{
NetworkTokenDetails, NetworkTokenDetailsPaymentMethod,
};
use josekit::jwe;
use masking::{ErasedMaskSerialize, ExposeInterface, Mask, PeekInterface, Secret};
use super::transformers::DeleteCardResp;
#[cfg(feature = "v2")]
use crate::utils::ext_traits::OptionExt;
use crate::{
core::{errors, payment_methods, payments::helpers},
headers, logger,
routes::{self, metrics},
services::{self, encryption},
settings,
types::{api, domain, payment_methods as pm_types},
};
pub const NETWORK_TOKEN_SERVICE: &str = "NETWORK_TOKEN";
#[cfg(feature = "v1")]
pub async fn mk_tokenization_req(
state: &routes::SessionState,
payload_bytes: &[u8],
customer_id: id_type::CustomerId,
tokenization_service: &settings::NetworkTokenizationService,
) -> CustomResult<
(pm_types::CardNetworkTokenResponsePayload, Option<String>),
errors::NetworkTokenizationError,
> {
let enc_key = tokenization_service.public_key.peek().clone();
let key_id = tokenization_service.key_id.clone();
let jwt = encryption::encrypt_jwe(
payload_bytes,
enc_key,
services::EncryptionAlgorithm::A128GCM,
Some(key_id.as_str()),
)
.await
.change_context(errors::NetworkTokenizationError::SaveNetworkTokenFailed)
.attach_printable("Error on jwe encrypt")?;
let order_data = pm_types::OrderData {
consent_id: uuid::Uuid::new_v4().to_string(),
customer_id,
};
let api_payload = pm_types::ApiPayload {
service: NETWORK_TOKEN_SERVICE.to_string(),
card_data: Secret::new(jwt),
order_data,
should_send_token: true,
};
let masked_request_body = api_payload
.masked_serialize()
.inspect_err(|e| logger::error!(error=?e, "failed to mask serialize"))
.unwrap_or(serde_json::json!({ "error": "failed to mask serialize"}));
logger::info!(raw_network_token_service_request=?masked_request_body);
let mut request = services::Request::new(
services::Method::Post,
tokenization_service.generate_token_url.as_str(),
);
request.add_header(headers::CONTENT_TYPE, "application/json".into());
request.add_header(
headers::AUTHORIZATION,
tokenization_service
.token_service_api_key
.peek()
.clone()
.into_masked(),
);
request.add_default_headers();
request.set_body(RequestContent::Json(Box::new(api_payload)));
logger::info!("Request to generate token: {:?}", request);
let response = services::call_connector_api(state, request, "generate_token")
.await
.change_context(errors::NetworkTokenizationError::ApiError);
let res = response
.change_context(errors::NetworkTokenizationError::ResponseDeserializationFailed)
.attach_printable("Error while receiving response")
.and_then(|inner| match inner {
Err(err_res) => {
let parsed_error: pm_types::NetworkTokenErrorResponse = err_res
.response
.parse_struct("Card Network Tokenization Response")
.change_context(
errors::NetworkTokenizationError::ResponseDeserializationFailed,
)?;
logger::error!(
error_code = %parsed_error.error_info.code,
developer_message = %parsed_error.error_info.developer_message,
"Network tokenization error: {:?}",
parsed_error.error_message
);
Err(errors::NetworkTokenizationError::ResponseDeserializationFailed)
.attach_printable(format!("Response Deserialization Failed: {err_res:?}"))
}
Ok(res) => Ok(res),
})
.inspect_err(|err| {
logger::error!("Error while deserializing response: {:?}", err);
})?;
let network_response: pm_types::CardNetworkTokenResponse = res
.response
.parse_struct("Card Network Tokenization Response")
.change_context(errors::NetworkTokenizationError::ResponseDeserializationFailed)?;
let dec_key = tokenization_service.private_key.peek().clone();
let card_network_token_response = services::decrypt_jwe(
network_response.payload.peek(),
services::KeyIdCheck::SkipKeyIdCheck,
dec_key,
jwe::RSA_OAEP_256,
)
.await
.change_context(errors::NetworkTokenizationError::SaveNetworkTokenFailed)
.attach_printable(
"Failed to decrypt the tokenization response from the tokenization service",
)?;
let cn_response: pm_types::CardNetworkTokenResponsePayload =
serde_json::from_str(&card_network_token_response)
.change_context(errors::NetworkTokenizationError::ResponseDeserializationFailed)?;
Ok((cn_response.clone(), Some(cn_response.card_reference)))
}
#[cfg(feature = "v2")]
pub async fn generate_network_token(
state: &routes::SessionState,
payload_bytes: &[u8],
customer_id: id_type::GlobalCustomerId,
tokenization_service: &settings::NetworkTokenizationService,
) -> CustomResult<
(pm_types::GenerateNetworkTokenResponsePayload, String),
errors::NetworkTokenizationError,
> {
let enc_key = tokenization_service.public_key.peek().clone();
let key_id = tokenization_service.key_id.clone();
let jwt = encryption::encrypt_jwe(
payload_bytes,
enc_key,
services::EncryptionAlgorithm::A128GCM,
Some(key_id.as_str()),
)
.await
.change_context(errors::NetworkTokenizationError::SaveNetworkTokenFailed)
.attach_printable("Error on jwe encrypt")?;
let order_data = pm_types::OrderData {
consent_id: uuid::Uuid::new_v4().to_string(),
customer_id,
};
let api_payload = pm_types::ApiPayload {
service: NETWORK_TOKEN_SERVICE.to_string(),
card_data: Secret::new(jwt),
order_data,
should_send_token: true,
};
let masked_request_body = api_payload
.masked_serialize()
.inspect_err(|e| logger::error!(error=?e, "failed to mask serialize"))
.unwrap_or(serde_json::json!({ "error": "failed to mask serialize"}));
logger::info!(raw_network_token_service_request=?masked_request_body);
let mut request = services::Request::new(
services::Method::Post,
tokenization_service.generate_token_url.as_str(),
);
request.add_header(headers::CONTENT_TYPE, "application/json".into());
request.add_header(
headers::AUTHORIZATION,
tokenization_service
.token_service_api_key
.peek()
.clone()
.into_masked(),
);
request.add_default_headers();
request.set_body(RequestContent::Json(Box::new(api_payload)));
logger::info!("Request to generate token: {:?}", request);
let response = services::call_connector_api(state, request, "generate_token")
.await
.change_context(errors::NetworkTokenizationError::ApiError);
let res = response
.change_context(errors::NetworkTokenizationError::ResponseDeserializationFailed)
.attach_printable("Error while receiving response")
.and_then(|inner| match inner {
Err(err_res) => {
let parsed_error: pm_types::NetworkTokenErrorResponse = err_res
.response
.parse_struct("Card Network Tokenization Response")
.change_context(
errors::NetworkTokenizationError::ResponseDeserializationFailed,
)?;
logger::error!(
error_code = %parsed_error.error_info.code,
developer_message = %parsed_error.error_info.developer_message,
"Network tokenization error: {:?}",
parsed_error.error_message
);
Err(errors::NetworkTokenizationError::ResponseDeserializationFailed)
.attach_printable(format!("Response Deserialization Failed: {err_res:?}"))
}
Ok(res) => Ok(res),
})
.inspect_err(|err| {
logger::error!("Error while deserializing response: {:?}", err);
})?;
let network_response: pm_types::CardNetworkTokenResponse = res
.response
.parse_struct("Card Network Tokenization Response")
.change_context(errors::NetworkTokenizationError::ResponseDeserializationFailed)?;
logger::debug!("Network Token Response: {:?}", network_response);
let dec_key = tokenization_service.private_key.peek().clone();
let card_network_token_response = services::decrypt_jwe(
network_response.payload.peek(),
services::KeyIdCheck::SkipKeyIdCheck,
dec_key,
jwe::RSA_OAEP_256,
)
.await
.change_context(errors::NetworkTokenizationError::SaveNetworkTokenFailed)
.attach_printable(
"Failed to decrypt the tokenization response from the tokenization service",
)?;
let cn_response: pm_types::GenerateNetworkTokenResponsePayload =
serde_json::from_str(&card_network_token_response)
.change_context(errors::NetworkTokenizationError::ResponseDeserializationFailed)?;
Ok((cn_response.clone(), cn_response.card_reference))
}
#[cfg(feature = "v1")]
pub async fn make_card_network_tokenization_request(
state: &routes::SessionState,
card: &domain::CardDetail,
optional_cvc: Option<Secret<String>>,
customer_id: &id_type::CustomerId,
) -> CustomResult<
(pm_types::CardNetworkTokenResponsePayload, Option<String>),
errors::NetworkTokenizationError,
> {
let card_data = pm_types::CardData {
card_number: card.card_number.clone(),
exp_month: card.card_exp_month.clone(),
exp_year: card.card_exp_year.clone(),
card_security_code: optional_cvc,
};
let payload = card_data
.encode_to_string_of_json()
.and_then(|x| x.encode_to_string_of_json())
.change_context(errors::NetworkTokenizationError::RequestEncodingFailed)?;
let payload_bytes = payload.as_bytes();
if let Some(network_tokenization_service) = &state.conf.network_tokenization_service {
record_operation_time(
async {
mk_tokenization_req(
state,
payload_bytes,
customer_id.clone(),
network_tokenization_service.get_inner(),
)
.await
.inspect_err(
|e| logger::error!(error=?e, "Error while making tokenization request"),
)
},
&metrics::GENERATE_NETWORK_TOKEN_TIME,
router_env::metric_attributes!(("locker", "rust")),
)
.await
} else {
Err(errors::NetworkTokenizationError::NetworkTokenizationServiceNotConfigured)
.inspect_err(|_| {
logger::error!("Network Tokenization Service not configured");
})
.attach_printable("Network Tokenization Service not configured")
}
}
#[cfg(feature = "v2")]
pub async fn make_card_network_tokenization_request(
state: &routes::SessionState,
card: &api_payment_methods::CardDetail,
customer_id: &id_type::GlobalCustomerId,
) -> CustomResult<(NetworkTokenDetails, String), errors::NetworkTokenizationError> {
let card_data = pm_types::CardData {
card_number: card.card_number.clone(),
exp_month: card.card_exp_month.clone(),
exp_year: card.card_exp_year.clone(),
card_security_code: None,
};
let payload = card_data
.encode_to_string_of_json()
.and_then(|x| x.encode_to_string_of_json())
.change_context(errors::NetworkTokenizationError::RequestEncodingFailed)?;
let payload_bytes = payload.as_bytes();
let network_tokenization_service = match &state.conf.network_tokenization_service {
Some(nt_service) => Ok(nt_service.get_inner()),
None => Err(report!(
errors::NetworkTokenizationError::NetworkTokenizationServiceNotConfigured
)),
}?;
let (resp, network_token_req_ref_id) = record_operation_time(
async {
generate_network_token(
state,
payload_bytes,
customer_id.clone(),
network_tokenization_service,
)
.await
.inspect_err(|e| logger::error!(error=?e, "Error while making tokenization request"))
},
&metrics::GENERATE_NETWORK_TOKEN_TIME,
router_env::metric_attributes!(("locker", "rust")),
)
.await?;
let network_token_details = NetworkTokenDetails {
network_token: resp.token,
network_token_exp_month: resp.token_expiry_month,
network_token_exp_year: resp.token_expiry_year,
card_issuer: card.card_issuer.clone(),
card_network: Some(resp.card_brand),
card_type: card.card_type.clone(),
card_issuing_country: card.card_issuing_country,
card_holder_name: card.card_holder_name.clone(),
nick_name: card.nick_name.clone(),
cryptogram: None,
};
Ok((network_token_details, network_token_req_ref_id))
}
#[cfg(feature = "v1")]
pub async fn get_network_token(
state: &routes::SessionState,
customer_id: id_type::CustomerId,
network_token_requestor_ref_id: String,
tokenization_service: &settings::NetworkTokenizationService,
) -> CustomResult<pm_types::TokenResponse, errors::NetworkTokenizationError> {
let mut request = services::Request::new(
services::Method::Post,
tokenization_service.fetch_token_url.as_str(),
);
let payload = pm_types::GetCardToken {
card_reference: network_token_requestor_ref_id,
customer_id,
};
let masked_request_body = payload
.masked_serialize()
.inspect_err(|e| logger::error!(error=?e, "failed to mask serialize"))
.unwrap_or(serde_json::json!({ "error": "failed to mask serialize"}));
logger::info!(raw_network_token_service_request=?masked_request_body);
request.add_header(headers::CONTENT_TYPE, "application/json".into());
request.add_header(
headers::AUTHORIZATION,
tokenization_service
.token_service_api_key
.clone()
.peek()
.clone()
.into_masked(),
);
request.add_default_headers();
request.set_body(RequestContent::Json(Box::new(payload)));
logger::info!("Request to fetch network token: {:?}", request);
// Send the request using `call_connector_api`
let response = services::call_connector_api(state, request, "get network token")
.await
.change_context(errors::NetworkTokenizationError::ApiError);
let res = response
.change_context(errors::NetworkTokenizationError::ResponseDeserializationFailed)
.attach_printable("Error while receiving response")
.and_then(|inner| match inner {
Err(err_res) => {
let parsed_error: pm_types::NetworkTokenErrorResponse = err_res
.response
.parse_struct("Card Network Tokenization Response")
.change_context(
errors::NetworkTokenizationError::ResponseDeserializationFailed,
)?;
logger::error!(
error_code = %parsed_error.error_info.code,
developer_message = %parsed_error.error_info.developer_message,
"Network tokenization error: {:?}",
parsed_error.error_message
);
Err(errors::NetworkTokenizationError::ResponseDeserializationFailed)
.attach_printable(format!("Response Deserialization Failed: {err_res:?}"))
}
Ok(res) => Ok(res),
})?;
let token_response: pm_types::TokenResponse = res
.response
.parse_struct("Get Network Token Response")
.change_context(errors::NetworkTokenizationError::ResponseDeserializationFailed)?;
logger::info!("Fetch Network Token Response: {:?}", token_response);
Ok(token_response)
}
#[cfg(feature = "v2")]
pub async fn get_network_token(
state: &routes::SessionState,
customer_id: &id_type::GlobalCustomerId,
network_token_requestor_ref_id: String,
tokenization_service: &settings::NetworkTokenizationService,
) -> CustomResult<pm_types::TokenResponse, errors::NetworkTokenizationError> {
let mut request = services::Request::new(
services::Method::Post,
tokenization_service.fetch_token_url.as_str(),
);
let payload = pm_types::GetCardToken {
card_reference: network_token_requestor_ref_id,
customer_id: customer_id.clone(),
};
let masked_request_body = payload
.masked_serialize()
.inspect_err(|e| logger::error!(error=?e, "failed to mask serialize"))
.unwrap_or(serde_json::json!({ "error": "failed to mask serialize"}));
logger::info!(raw_network_token_service_request=?masked_request_body);
request.add_header(headers::CONTENT_TYPE, "application/json".into());
request.add_header(
headers::AUTHORIZATION,
tokenization_service
.token_service_api_key
.clone()
.peek()
.clone()
.into_masked(),
);
request.add_default_headers();
request.set_body(RequestContent::Json(Box::new(payload)));
logger::info!("Request to fetch network token: {:?}", request);
// Send the request using `call_connector_api`
let response = services::call_connector_api(state, request, "get network token")
.await
.change_context(errors::NetworkTokenizationError::ApiError);
let res = response
.change_context(errors::NetworkTokenizationError::ResponseDeserializationFailed)
.attach_printable("Error while receiving response")
.and_then(|inner| match inner {
Err(err_res) => {
let parsed_error: pm_types::NetworkTokenErrorResponse = err_res
.response
.parse_struct("Card Network Tokenization Response")
.change_context(
errors::NetworkTokenizationError::ResponseDeserializationFailed,
)?;
logger::error!(
error_code = %parsed_error.error_info.code,
developer_message = %parsed_error.error_info.developer_message,
"Network tokenization error: {:?}",
parsed_error.error_message
);
Err(errors::NetworkTokenizationError::ResponseDeserializationFailed)
.attach_printable(format!("Response Deserialization Failed: {err_res:?}"))
}
Ok(res) => Ok(res),
})?;
let token_response: pm_types::TokenResponse = res
.response
.parse_struct("Get Network Token Response")
.change_context(errors::NetworkTokenizationError::ResponseDeserializationFailed)?;
logger::info!("Fetch Network Token Response: {:?}", token_response);
Ok(token_response)
}
#[cfg(feature = "v1")]
pub async fn get_token_from_tokenization_service(
state: &routes::SessionState,
network_token_requestor_ref_id: String,
pm_data: &domain::PaymentMethod,
) -> errors::RouterResult<domain::NetworkTokenData> {
let token_response =
if let Some(network_tokenization_service) = &state.conf.network_tokenization_service {
record_operation_time(
async {
get_network_token(
state,
pm_data.customer_id.clone(),
network_token_requestor_ref_id,
network_tokenization_service.get_inner(),
)
.await
.inspect_err(
|e| logger::error!(error=?e, "Error while fetching token from tokenization service")
)
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Fetch network token failed")
},
&metrics::FETCH_NETWORK_TOKEN_TIME,
&[],
)
.await
} else {
Err(errors::NetworkTokenizationError::NetworkTokenizationServiceNotConfigured)
.inspect_err(|err| {
logger::error!(error=? err);
})
.change_context(errors::ApiErrorResponse::InternalServerError)
}?;
let token_decrypted = pm_data
.network_token_payment_method_data
.clone()
.map(|x| x.into_inner().expose())
.and_then(|v| serde_json::from_value::<api_payment_methods::PaymentMethodsData>(v).ok())
.and_then(|pmd| match pmd {
api_payment_methods::PaymentMethodsData::Card(token) => {
Some(api::CardDetailFromLocker::from(token))
}
_ => None,
})
.ok_or(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed to obtain decrypted token object from db")?;
let network_token_data = domain::NetworkTokenData {
token_number: token_response.authentication_details.token,
token_cryptogram: Some(token_response.authentication_details.cryptogram),
token_exp_month: token_decrypted
.expiry_month
.unwrap_or(token_response.token_details.exp_month),
token_exp_year: token_decrypted
.expiry_year
.unwrap_or(token_response.token_details.exp_year),
nick_name: token_decrypted.card_holder_name,
card_issuer: None,
card_network: Some(token_response.network),
card_type: None,
card_issuing_country: None,
bank_code: None,
eci: token_response.eci,
};
Ok(network_token_data)
}
#[cfg(feature = "v2")]
pub async fn get_token_from_tokenization_service(
state: &routes::SessionState,
network_token_requestor_ref_id: String,
pm_data: &domain::PaymentMethod,
) -> errors::RouterResult<domain::NetworkTokenData> {
let customer_id = &pm_data
.customer_id
.clone()
.get_required_value("GlobalCustomerId")?;
let token_response =
if let Some(network_tokenization_service) = &state.conf.network_tokenization_service {
record_operation_time(
async {
get_network_token(
state,
customer_id,
network_token_requestor_ref_id,
network_tokenization_service.get_inner(),
)
.await
.inspect_err(
|e| logger::error!(error=?e, "Error while fetching token from tokenization service")
)
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Fetch network token failed")
},
&metrics::FETCH_NETWORK_TOKEN_TIME,
&[],
)
.await
} else {
Err(errors::NetworkTokenizationError::NetworkTokenizationServiceNotConfigured)
.inspect_err(|err| {
logger::error!(error=? err);
})
.change_context(errors::ApiErrorResponse::InternalServerError)
}?;
let token_decrypted = pm_data
.network_token_payment_method_data
.clone()
.map(|value| value.into_inner())
.and_then(|payment_method_data| match payment_method_data {
hyperswitch_domain_models::payment_method_data::PaymentMethodsData::NetworkToken(
token,
) => Some(token),
_ => None,
})
.ok_or(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed to obtain decrypted token object from db")?;
let network_token_data = domain::NetworkTokenData {
network_token: token_response.authentication_details.token,
cryptogram: Some(token_response.authentication_details.cryptogram),
network_token_exp_month: token_decrypted
.network_token_expiry_month
.unwrap_or(token_response.token_details.exp_month),
network_token_exp_year: token_decrypted
.network_token_expiry_year
.unwrap_or(token_response.token_details.exp_year),
card_holder_name: token_decrypted.card_holder_name,
nick_name: token_decrypted.nick_name.or(token_response.nickname),
card_issuer: token_decrypted.card_issuer.or(token_response.issuer),
card_network: Some(token_response.network),
card_type: token_decrypted
.card_type
.or(token_response.card_type)
.as_ref()
.map(|c| api_payment_methods::CardType::from_str(c))
.transpose()
.ok()
.flatten(),
card_issuing_country: token_decrypted.issuer_country,
bank_code: None,
eci: token_response.eci,
};
Ok(network_token_data)
}
#[cfg(feature = "v1")]
pub async fn do_status_check_for_network_token(
state: &routes::SessionState,
payment_method_info: &domain::PaymentMethod,
) -> CustomResult<(Option<Secret<String>>, Option<Secret<String>>), errors::ApiErrorResponse> {
let network_token_data_decrypted = payment_method_info
.network_token_payment_method_data
.clone()
.map(|x| x.into_inner().expose())
.and_then(|v| serde_json::from_value::<api_payment_methods::PaymentMethodsData>(v).ok())
.and_then(|pmd| match pmd {
api_payment_methods::PaymentMethodsData::Card(token) => {
Some(api::CardDetailFromLocker::from(token))
}
_ => None,
});
let network_token_requestor_reference_id = payment_method_info
.network_token_requestor_reference_id
.clone();
if network_token_data_decrypted
.and_then(|token_data| token_data.expiry_month.zip(token_data.expiry_year))
.and_then(|(exp_month, exp_year)| helpers::validate_card_expiry(&exp_month, &exp_year).ok())
.is_none()
{
if let Some(ref_id) = network_token_requestor_reference_id {
if let Some(network_tokenization_service) = &state.conf.network_tokenization_service {
let (token_exp_month, token_exp_year) = record_operation_time(
async {
check_token_status_with_tokenization_service(
state,
&payment_method_info.customer_id.clone(),
ref_id,
network_tokenization_service.get_inner(),
)
.await
.inspect_err(
|e| logger::error!(error=?e, "Error while fetching token from tokenization service")
)
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable(
"Check network token status with tokenization service failed",
)
},
&metrics::CHECK_NETWORK_TOKEN_STATUS_TIME,
&[],
)
.await?;
Ok((token_exp_month, token_exp_year))
} else {
Err(errors::NetworkTokenizationError::NetworkTokenizationServiceNotConfigured)
.change_context(errors::ApiErrorResponse::InternalServerError)
.inspect_err(|_| {
logger::error!("Network Tokenization Service not configured");
})
}
} else {
Err(errors::NetworkTokenizationError::FetchNetworkTokenFailed)
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Check network token status failed")?
}
} else {
Ok((None, None))
}
}
#[cfg(feature = "v1")]
pub async fn check_token_status_with_tokenization_service(
state: &routes::SessionState,
customer_id: &id_type::CustomerId,
network_token_requestor_reference_id: String,
tokenization_service: &settings::NetworkTokenizationService,
) -> CustomResult<(Option<Secret<String>>, Option<Secret<String>>), errors::NetworkTokenizationError>
{
let mut request = services::Request::new(
services::Method::Post,
tokenization_service.check_token_status_url.as_str(),
);
let payload = pm_types::CheckTokenStatus {
card_reference: network_token_requestor_reference_id,
customer_id: customer_id.clone(),
};
let masked_request_body = payload
.masked_serialize()
.inspect_err(|e| logger::error!(error=?e, "failed to mask serialize"))
.unwrap_or(serde_json::json!({ "error": "failed to mask serialize"}));
logger::info!(raw_network_token_service_request=?masked_request_body);
request.add_header(headers::CONTENT_TYPE, "application/json".into());
request.add_header(
headers::AUTHORIZATION,
tokenization_service
.token_service_api_key
.clone()
.peek()
.clone()
.into_masked(),
);
request.add_default_headers();
request.set_body(RequestContent::Json(Box::new(payload)));
// Send the request using `call_connector_api`
let response = services::call_connector_api(state, request, "Check Network token Status")
.await
.change_context(errors::NetworkTokenizationError::ApiError);
let res = response
.change_context(errors::NetworkTokenizationError::ResponseDeserializationFailed)
.attach_printable("Error while receiving response")
.and_then(|inner| match inner {
Err(err_res) => {
let parsed_error: pm_types::NetworkTokenErrorResponse = err_res
.response
.parse_struct("Delete Network Tokenization Response")
.change_context(
errors::NetworkTokenizationError::ResponseDeserializationFailed,
)?;
logger::error!(
error_code = %parsed_error.error_info.code,
developer_message = %parsed_error.error_info.developer_message,
"Network tokenization error: {:?}",
parsed_error.error_message
);
Err(errors::NetworkTokenizationError::ResponseDeserializationFailed)
.attach_printable(format!("Response Deserialization Failed: {err_res:?}"))
}
Ok(res) => Ok(res),
})
.inspect_err(|err| {
logger::error!("Error while deserializing response: {:?}", err);
})?;
let check_token_status_response: pm_types::CheckTokenStatusResponse = res
.response
.parse_struct("Delete Network Tokenization Response")
.change_context(errors::NetworkTokenizationError::ResponseDeserializationFailed)?;
match check_token_status_response.payload.token_status {
pm_types::TokenStatus::Active => Ok((
check_token_status_response.payload.token_expiry_month,
check_token_status_response.payload.token_expiry_year,
)),
_ => Ok((None, None)),
}
}
#[cfg(feature = "v2")]
pub async fn check_token_status_with_tokenization_service(
state: &routes::SessionState,
customer_id: &id_type::GlobalCustomerId,
network_token_requestor_reference_id: String,
tokenization_service: &settings::NetworkTokenizationService,
) -> CustomResult<pm_types::CheckTokenStatusResponse, errors::NetworkTokenizationError> {
let mut request = services::Request::new(
services::Method::Post,
tokenization_service.check_token_status_url.as_str(),
);
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | true |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/payment_methods/utils.rs | crates/router/src/core/payment_methods/utils.rs | use std::{str::FromStr, sync::Arc};
use api_models::{
admin::{self, PaymentMethodsEnabled},
enums as api_enums,
payment_methods::RequestPaymentMethodTypes,
};
use common_enums::enums;
#[cfg(feature = "v2")]
use common_utils::ext_traits::{OptionExt, StringExt};
#[cfg(feature = "v2")]
use error_stack::ResultExt;
use euclid::frontend::dir;
use hyperswitch_constraint_graph as cgraph;
use kgraph_utils::{error::KgraphError, transformers::IntoDirValue};
use masking::ExposeInterface;
#[cfg(feature = "v1")]
use router_env::logger;
use storage_impl::redis::cache::{CacheKey, PM_FILTERS_CGRAPH_CACHE};
use crate::{configs::settings, db::StorageInterface, routes::SessionState};
#[cfg(feature = "v2")]
use crate::{
db::{
errors,
storage::{self, enums as storage_enums},
},
services::logger,
};
pub fn make_pm_graph(
builder: &mut cgraph::ConstraintGraphBuilder<dir::DirValue>,
domain_id: cgraph::DomainId,
payment_methods: &[masking::Secret<serde_json::value::Value>],
connector: String,
pm_config_mapping: &settings::ConnectorFilters,
supported_payment_methods_for_mandate: &settings::SupportedPaymentMethodsForMandate,
supported_payment_methods_for_update_mandate: &settings::SupportedPaymentMethodsForMandate,
) -> Result<(), KgraphError> {
for payment_method in payment_methods.iter() {
let pm_enabled =
serde_json::from_value::<PaymentMethodsEnabled>(payment_method.clone().expose());
if let Ok(payment_methods_enabled) = pm_enabled {
compile_pm_graph(
builder,
domain_id,
payment_methods_enabled.clone(),
connector.clone(),
pm_config_mapping,
supported_payment_methods_for_mandate,
supported_payment_methods_for_update_mandate,
)?;
};
}
Ok(())
}
pub async fn get_merchant_pm_filter_graph(
state: &SessionState,
key: &str,
) -> Option<Arc<hyperswitch_constraint_graph::ConstraintGraph<dir::DirValue>>> {
PM_FILTERS_CGRAPH_CACHE
.get_val::<Arc<hyperswitch_constraint_graph::ConstraintGraph<dir::DirValue>>>(CacheKey {
key: key.to_string(),
prefix: state.tenant.redis_key_prefix.clone(),
})
.await
}
pub async fn refresh_pm_filters_cache(
state: &SessionState,
key: &str,
graph: cgraph::ConstraintGraph<dir::DirValue>,
) -> Arc<hyperswitch_constraint_graph::ConstraintGraph<dir::DirValue>> {
let pm_filter_graph = Arc::new(graph);
PM_FILTERS_CGRAPH_CACHE
.push(
CacheKey {
key: key.to_string(),
prefix: state.tenant.redis_key_prefix.clone(),
},
pm_filter_graph.clone(),
)
.await;
pm_filter_graph
}
fn compile_pm_graph(
builder: &mut cgraph::ConstraintGraphBuilder<dir::DirValue>,
domain_id: cgraph::DomainId,
pm_enabled: PaymentMethodsEnabled,
connector: String,
config: &settings::ConnectorFilters,
supported_payment_methods_for_mandate: &settings::SupportedPaymentMethodsForMandate,
supported_payment_methods_for_update_mandate: &settings::SupportedPaymentMethodsForMandate,
) -> Result<(), KgraphError> {
if let Some(payment_method_types) = pm_enabled.payment_method_types {
for pmt in payment_method_types {
let mut agg_nodes: Vec<(cgraph::NodeId, cgraph::Relation, cgraph::Strength)> =
Vec::new();
let mut agg_or_nodes_for_mandate_filters: Vec<(
cgraph::NodeId,
cgraph::Relation,
cgraph::Strength,
)> = Vec::new();
// Connector supported for Update mandate filter
let res = construct_supported_connectors_for_update_mandate_node(
builder,
domain_id,
supported_payment_methods_for_update_mandate,
pmt.clone(),
pm_enabled.payment_method,
);
if let Ok(Some(connector_eligible_for_update_mandates_node)) = res {
agg_or_nodes_for_mandate_filters.push((
connector_eligible_for_update_mandates_node,
cgraph::Relation::Positive,
cgraph::Strength::Strong,
))
}
// Connector supported for mandates filter
if let Some(supported_pm_for_mandates) = supported_payment_methods_for_mandate
.0
.get(&pm_enabled.payment_method)
{
if let Some(supported_connector_for_mandates) =
supported_pm_for_mandates.0.get(&pmt.payment_method_type)
{
let supported_connectors: Vec<api_enums::Connector> =
supported_connector_for_mandates
.connector_list
.clone()
.into_iter()
.collect();
if let Ok(Some(connector_eligible_for_mandates_node)) =
construct_supported_connectors_for_mandate_node(
builder,
domain_id,
supported_connectors,
)
{
agg_or_nodes_for_mandate_filters.push((
connector_eligible_for_mandates_node,
cgraph::Relation::Positive,
cgraph::Strength::Strong,
))
}
}
}
// Non Prominent Mandate flows
let payment_type_non_mandate_value_node = builder.make_value_node(
cgraph::NodeValue::Value(dir::DirValue::PaymentType(
euclid::enums::PaymentType::NonMandate,
)),
None,
None::<()>,
);
let payment_type_setup_mandate_value_node = builder.make_value_node(
cgraph::NodeValue::Value(dir::DirValue::PaymentType(
euclid::enums::PaymentType::SetupMandate,
)),
None,
None::<()>,
);
let non_major_mandate_any_node = builder
.make_any_aggregator(
&[
(
payment_type_non_mandate_value_node,
cgraph::Relation::Positive,
cgraph::Strength::Strong,
),
(
payment_type_setup_mandate_value_node,
cgraph::Relation::Positive,
cgraph::Strength::Strong,
),
],
None,
None::<()>,
Some(domain_id),
)
.map_err(KgraphError::GraphConstructionError)?;
agg_or_nodes_for_mandate_filters.push((
non_major_mandate_any_node,
cgraph::Relation::Positive,
cgraph::Strength::Strong,
));
let agg_or_node = builder
.make_any_aggregator(
&agg_or_nodes_for_mandate_filters,
None,
None::<()>,
Some(domain_id),
)
.map_err(KgraphError::GraphConstructionError)?;
agg_nodes.push((
agg_or_node,
cgraph::Relation::Positive,
cgraph::Strength::Strong,
));
// Capture Method filter
config
.0
.get(connector.as_str())
.or_else(|| config.0.get("default"))
.map(|inner| {
if let Ok(Some(capture_method_filter)) =
construct_capture_method_node(builder, inner, pmt.payment_method_type)
{
agg_nodes.push((
capture_method_filter,
cgraph::Relation::Negative,
cgraph::Strength::Strong,
))
}
});
// Country filter
if let Ok(Some(country_node)) = compile_accepted_countries_for_mca(
builder,
domain_id,
pmt.payment_method_type,
pmt.accepted_countries,
config,
connector.clone(),
) {
agg_nodes.push((
country_node,
cgraph::Relation::Positive,
cgraph::Strength::Strong,
))
}
// Currency filter
if let Ok(Some(currency_node)) = compile_accepted_currency_for_mca(
builder,
domain_id,
pmt.payment_method_type,
pmt.accepted_currencies,
config,
connector.clone(),
) {
agg_nodes.push((
currency_node,
cgraph::Relation::Positive,
cgraph::Strength::Strong,
))
}
let and_node_for_all_the_filters = builder
.make_all_aggregator(&agg_nodes, None, None::<()>, Some(domain_id))
.map_err(KgraphError::GraphConstructionError)?;
// Making our output node
let pmt_info = "PaymentMethodType";
let dir_node: cgraph::NodeValue<dir::DirValue> =
(pmt.payment_method_type, pm_enabled.payment_method)
.into_dir_value()
.map(Into::into)?;
let payment_method_type_value_node =
builder.make_value_node(dir_node, Some(pmt_info), None::<()>);
builder
.make_edge(
and_node_for_all_the_filters,
payment_method_type_value_node,
cgraph::Strength::Normal,
cgraph::Relation::Positive,
Some(domain_id),
)
.map_err(KgraphError::GraphConstructionError)?;
}
}
Ok(())
}
fn construct_supported_connectors_for_update_mandate_node(
builder: &mut cgraph::ConstraintGraphBuilder<dir::DirValue>,
domain_id: cgraph::DomainId,
supported_payment_methods_for_update_mandate: &settings::SupportedPaymentMethodsForMandate,
pmt: RequestPaymentMethodTypes,
payment_method: enums::PaymentMethod,
) -> Result<Option<cgraph::NodeId>, KgraphError> {
let card_value_node = builder.make_value_node(
cgraph::NodeValue::Value(dir::DirValue::PaymentMethod(enums::PaymentMethod::Card)),
None,
None::<()>,
);
let payment_type_value_node = builder.make_value_node(
cgraph::NodeValue::Value(dir::DirValue::PaymentType(
euclid::enums::PaymentType::UpdateMandate,
)),
None,
None::<()>,
);
let mut agg_nodes: Vec<(cgraph::NodeId, cgraph::Relation, cgraph::Strength)> = Vec::new();
let mut card_dir_values = Vec::new();
let mut non_card_dir_values = Vec::new();
if let Some(supported_pm_for_mandates) = supported_payment_methods_for_update_mandate
.0
.get(&payment_method)
{
if payment_method == enums::PaymentMethod::Card {
if let Some(credit_connector_list) = supported_pm_for_mandates
.0
.get(&api_enums::PaymentMethodType::Credit)
{
card_dir_values.extend(
credit_connector_list
.connector_list
.clone()
.into_iter()
.filter_map(|connector| {
api_enums::RoutableConnectors::from_str(connector.to_string().as_str())
.ok()
.map(|connector| {
dir::DirValue::Connector(Box::new(
api_models::routing::ast::ConnectorChoice { connector },
))
})
}),
);
}
if let Some(debit_connector_list) = supported_pm_for_mandates
.0
.get(&api_enums::PaymentMethodType::Debit)
{
card_dir_values.extend(
debit_connector_list
.connector_list
.clone()
.into_iter()
.filter_map(|connector| {
api_enums::RoutableConnectors::from_str(connector.to_string().as_str())
.ok()
.map(|connector| {
dir::DirValue::Connector(Box::new(
api_models::routing::ast::ConnectorChoice { connector },
))
})
}),
);
}
let card_in_node = builder
.make_in_aggregator(card_dir_values, None, None::<()>)
.map_err(KgraphError::GraphConstructionError)?;
let card_and_node = builder
.make_all_aggregator(
&[
(
card_value_node,
cgraph::Relation::Positive,
cgraph::Strength::Strong,
),
(
payment_type_value_node,
cgraph::Relation::Positive,
cgraph::Strength::Strong,
),
(
card_in_node,
cgraph::Relation::Positive,
cgraph::Strength::Strong,
),
],
None,
None::<()>,
Some(domain_id),
)
.map_err(KgraphError::GraphConstructionError)?;
agg_nodes.push((
card_and_node,
cgraph::Relation::Positive,
cgraph::Strength::Strong,
));
} else if let Some(connector_list) =
supported_pm_for_mandates.0.get(&pmt.payment_method_type)
{
non_card_dir_values.extend(
connector_list
.connector_list
.clone()
.into_iter()
.filter_map(|connector| {
api_enums::RoutableConnectors::from_str(connector.to_string().as_str())
.ok()
.map(|connector| {
dir::DirValue::Connector(Box::new(
api_models::routing::ast::ConnectorChoice { connector },
))
})
}),
);
let non_card_mandate_in_node = builder
.make_in_aggregator(non_card_dir_values, None, None::<()>)
.map_err(KgraphError::GraphConstructionError)?;
let non_card_and_node = builder
.make_all_aggregator(
&[
(
card_value_node,
cgraph::Relation::Negative,
cgraph::Strength::Strong,
),
(
payment_type_value_node,
cgraph::Relation::Positive,
cgraph::Strength::Strong,
),
(
non_card_mandate_in_node,
cgraph::Relation::Positive,
cgraph::Strength::Strong,
),
],
None,
None::<()>,
Some(domain_id),
)
.map_err(KgraphError::GraphConstructionError)?;
agg_nodes.push((
non_card_and_node,
cgraph::Relation::Positive,
cgraph::Strength::Strong,
));
}
}
if !agg_nodes.is_empty() {
Ok(Some(
builder
.make_any_aggregator(
&agg_nodes,
Some("any node for card and non card pm"),
None::<()>,
Some(domain_id),
)
.map_err(KgraphError::GraphConstructionError)?,
))
} else {
Ok(None)
}
}
fn construct_supported_connectors_for_mandate_node(
builder: &mut cgraph::ConstraintGraphBuilder<dir::DirValue>,
domain_id: cgraph::DomainId,
eligible_connectors: Vec<api_enums::Connector>,
) -> Result<Option<cgraph::NodeId>, KgraphError> {
let payment_type_value_node = builder.make_value_node(
cgraph::NodeValue::Value(dir::DirValue::PaymentType(
euclid::enums::PaymentType::NewMandate,
)),
None,
None::<()>,
);
let connectors_from_config: Vec<dir::DirValue> = eligible_connectors
.into_iter()
.filter_map(|connector| {
match api_enums::RoutableConnectors::from_str(connector.to_string().as_str()) {
Ok(connector) => Some(dir::DirValue::Connector(Box::new(
api_models::routing::ast::ConnectorChoice { connector },
))),
Err(_) => None,
}
})
.collect();
if connectors_from_config.is_empty() {
Ok(None)
} else {
let connector_in_aggregator = builder
.make_in_aggregator(connectors_from_config, None, None::<()>)
.map_err(KgraphError::GraphConstructionError)?;
Ok(Some(
builder
.make_all_aggregator(
&[
(
payment_type_value_node,
cgraph::Relation::Positive,
cgraph::Strength::Strong,
),
(
connector_in_aggregator,
cgraph::Relation::Positive,
cgraph::Strength::Strong,
),
],
None,
None::<()>,
Some(domain_id),
)
.map_err(KgraphError::GraphConstructionError)?,
))
}
}
fn construct_capture_method_node(
builder: &mut cgraph::ConstraintGraphBuilder<dir::DirValue>,
payment_method_filters: &settings::PaymentMethodFilters,
payment_method_type: api_enums::PaymentMethodType,
) -> Result<Option<cgraph::NodeId>, KgraphError> {
if !payment_method_filters
.0
.get(&settings::PaymentMethodFilterKey::PaymentMethodType(
payment_method_type,
))
.and_then(|v| v.not_available_flows)
.and_then(|v| v.capture_method)
.map(|v| !matches!(v, api_enums::CaptureMethod::Manual))
.unwrap_or(true)
{
return Ok(Some(builder.make_value_node(
cgraph::NodeValue::Value(dir::DirValue::CaptureMethod(
common_enums::CaptureMethod::Manual,
)),
None,
None::<()>,
)));
}
Ok(None)
}
// fn construct_card_network_nodes(
// builder: &mut cgraph::ConstraintGraphBuilder<dir::DirValue>,
// mca_card_networks: Vec<api_enums::CardNetwork>,
// ) -> Result<Option<cgraph::NodeId>, KgraphError> {
// Ok(Some(
// builder
// .make_in_aggregator(
// mca_card_networks
// .into_iter()
// .map(dir::DirValue::CardNetwork)
// .collect(),
// None,
// None::<()>,
// )
// .map_err(KgraphError::GraphConstructionError)?,
// ))
// }
fn compile_accepted_countries_for_mca(
builder: &mut cgraph::ConstraintGraphBuilder<dir::DirValue>,
domain_id: cgraph::DomainId,
payment_method_type: enums::PaymentMethodType,
pm_countries: Option<admin::AcceptedCountries>,
config: &settings::ConnectorFilters,
connector: String,
) -> Result<Option<cgraph::NodeId>, KgraphError> {
let mut agg_nodes: Vec<(cgraph::NodeId, cgraph::Relation, cgraph::Strength)> = Vec::new();
// Country from the MCA
if let Some(pm_obj_countries) = pm_countries {
match pm_obj_countries {
admin::AcceptedCountries::EnableOnly(countries) => {
let pm_object_country_value_node = builder
.make_in_aggregator(
countries
.into_iter()
.map(|country| {
dir::DirValue::BillingCountry(common_enums::Country::from_alpha2(
country,
))
})
.collect(),
None,
None::<()>,
)
.map_err(KgraphError::GraphConstructionError)?;
agg_nodes.push((
pm_object_country_value_node,
cgraph::Relation::Positive,
cgraph::Strength::Weak,
));
}
admin::AcceptedCountries::DisableOnly(countries) => {
let pm_object_country_value_node = builder
.make_in_aggregator(
countries
.into_iter()
.map(|country| {
dir::DirValue::BillingCountry(common_enums::Country::from_alpha2(
country,
))
})
.collect(),
None,
None::<()>,
)
.map_err(KgraphError::GraphConstructionError)?;
agg_nodes.push((
pm_object_country_value_node,
cgraph::Relation::Negative,
cgraph::Strength::Weak,
));
}
admin::AcceptedCountries::AllAccepted => return Ok(None),
}
}
// country from config
if let Some(derived_config) = config
.0
.get(connector.as_str())
.or_else(|| config.0.get("default"))
{
if let Some(value) =
derived_config
.0
.get(&settings::PaymentMethodFilterKey::PaymentMethodType(
payment_method_type,
))
{
if let Some(config_countries) = value.country.as_ref() {
let config_countries: Vec<common_enums::Country> = Vec::from_iter(config_countries)
.into_iter()
.map(|country| common_enums::Country::from_alpha2(*country))
.collect();
let dir_countries: Vec<dir::DirValue> = config_countries
.into_iter()
.map(dir::DirValue::BillingCountry)
.collect();
let config_country_agg_node = builder
.make_in_aggregator(dir_countries, None, None::<()>)
.map_err(KgraphError::GraphConstructionError)?;
agg_nodes.push((
config_country_agg_node,
cgraph::Relation::Positive,
cgraph::Strength::Weak,
));
}
} else if let Some(default_derived_config) = config.0.get("default") {
if let Some(value) =
default_derived_config
.0
.get(&settings::PaymentMethodFilterKey::PaymentMethodType(
payment_method_type,
))
{
if let Some(config_countries) = value.country.as_ref() {
let config_countries: Vec<common_enums::Country> =
Vec::from_iter(config_countries)
.into_iter()
.map(|country| common_enums::Country::from_alpha2(*country))
.collect();
let dir_countries: Vec<dir::DirValue> = config_countries
.into_iter()
.map(dir::DirValue::BillingCountry)
.collect();
let config_country_agg_node = builder
.make_in_aggregator(dir_countries, None, None::<()>)
.map_err(KgraphError::GraphConstructionError)?;
agg_nodes.push((
config_country_agg_node,
cgraph::Relation::Positive,
cgraph::Strength::Weak,
));
}
}
};
}
Ok(Some(
builder
.make_all_aggregator(&agg_nodes, None, None::<()>, Some(domain_id))
.map_err(KgraphError::GraphConstructionError)?,
))
}
fn compile_accepted_currency_for_mca(
builder: &mut cgraph::ConstraintGraphBuilder<dir::DirValue>,
domain_id: cgraph::DomainId,
payment_method_type: enums::PaymentMethodType,
pm_currency: Option<admin::AcceptedCurrencies>,
config: &settings::ConnectorFilters,
connector: String,
) -> Result<Option<cgraph::NodeId>, KgraphError> {
let mut agg_nodes: Vec<(cgraph::NodeId, cgraph::Relation, cgraph::Strength)> = Vec::new();
// Currency from the MCA
if let Some(pm_obj_currency) = pm_currency {
match pm_obj_currency {
admin::AcceptedCurrencies::EnableOnly(currency) => {
let pm_object_currency_value_node = builder
.make_in_aggregator(
currency
.into_iter()
.map(dir::DirValue::PaymentCurrency)
.collect(),
None,
None::<()>,
)
.map_err(KgraphError::GraphConstructionError)?;
agg_nodes.push((
pm_object_currency_value_node,
cgraph::Relation::Positive,
cgraph::Strength::Weak,
));
}
admin::AcceptedCurrencies::DisableOnly(currency) => {
let pm_object_currency_value_node = builder
.make_in_aggregator(
currency
.into_iter()
.map(dir::DirValue::PaymentCurrency)
.collect(),
None,
None::<()>,
)
.map_err(KgraphError::GraphConstructionError)?;
agg_nodes.push((
pm_object_currency_value_node,
cgraph::Relation::Negative,
cgraph::Strength::Weak,
));
}
admin::AcceptedCurrencies::AllAccepted => return Ok(None),
}
}
// currency from config
if let Some(derived_config) = config
.0
.get(connector.as_str())
.or_else(|| config.0.get("default"))
{
if let Some(value) =
derived_config
.0
.get(&settings::PaymentMethodFilterKey::PaymentMethodType(
payment_method_type,
))
{
if let Some(config_currencies) = value.currency.as_ref() {
let config_currency: Vec<common_enums::Currency> =
Vec::from_iter(config_currencies)
.into_iter()
.copied()
.collect();
let dir_currencies: Vec<dir::DirValue> = config_currency
.into_iter()
.map(dir::DirValue::PaymentCurrency)
.collect();
let config_currency_agg_node = builder
.make_in_aggregator(dir_currencies, None, None::<()>)
.map_err(KgraphError::GraphConstructionError)?;
agg_nodes.push((
config_currency_agg_node,
cgraph::Relation::Positive,
cgraph::Strength::Weak,
));
}
} else if let Some(default_derived_config) = config.0.get("default") {
if let Some(value) =
default_derived_config
.0
.get(&settings::PaymentMethodFilterKey::PaymentMethodType(
payment_method_type,
))
{
if let Some(config_currencies) = value.currency.as_ref() {
let config_currency: Vec<common_enums::Currency> =
Vec::from_iter(config_currencies)
.into_iter()
.copied()
.collect();
let dir_currencies: Vec<dir::DirValue> = config_currency
.into_iter()
.map(dir::DirValue::PaymentCurrency)
.collect();
let config_currency_agg_node = builder
.make_in_aggregator(dir_currencies, None, None::<()>)
.map_err(KgraphError::GraphConstructionError)?;
agg_nodes.push((
config_currency_agg_node,
cgraph::Relation::Positive,
cgraph::Strength::Weak,
))
}
}
};
}
Ok(Some(
builder
.make_all_aggregator(&agg_nodes, None, None::<()>, Some(domain_id))
.map_err(KgraphError::GraphConstructionError)?,
))
}
pub async fn get_merchant_config_for_eligibility_check(
db: &dyn StorageInterface,
merchant_id: &common_utils::id_type::MerchantId,
) -> bool {
let config = db
.find_config_by_key_unwrap_or(
&merchant_id.get_should_perform_eligibility_check_key(),
Some("false".to_string()),
)
.await;
match config {
Ok(conf) => conf.config == "true",
Err(error) => {
logger::error!(?error);
false
}
}
}
pub async fn get_sdk_next_action_for_payment_method_list(
db: &dyn StorageInterface,
merchant_id: &common_utils::id_type::MerchantId,
) -> api_models::payments::SdkNextAction {
let should_perform_eligibility_check =
get_merchant_config_for_eligibility_check(db, merchant_id).await;
let next_action_call = if should_perform_eligibility_check {
api_models::payments::NextActionCall::EligibilityCheck
} else {
api_models::payments::NextActionCall::Confirm
};
api_models::payments::SdkNextAction {
next_action: next_action_call,
}
}
#[cfg(feature = "v2")]
pub(super) async fn retrieve_payment_token_data(
state: &SessionState,
token: String,
payment_method: Option<&storage_enums::PaymentMethod>,
) -> errors::RouterResult<storage::PaymentTokenData> {
let redis_conn = state
.store
.get_redis_conn()
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed to get redis connection")?;
let key = format!(
"pm_token_{}_{}_hyperswitch",
token,
payment_method
.get_required_value("payment_method")
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Payment method is required")?
);
let token_data_string = redis_conn
.get_key::<Option<String>>(&key.into())
.await
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | true |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/payment_methods/validator.rs | crates/router/src/core/payment_methods/validator.rs | use api_models::{admin, payment_methods::PaymentMethodCollectLinkRequest};
use common_utils::link_utils;
use diesel_models::generic_link::PaymentMethodCollectLinkData;
use error_stack::ResultExt;
use masking::Secret;
use crate::{
consts,
core::{
errors::{self, RouterResult},
utils as core_utils,
},
routes::{app::StorageInterface, SessionState},
types::domain,
utils,
};
#[cfg(feature = "v2")]
pub async fn validate_request_and_initiate_payment_method_collect_link(
_state: &SessionState,
_platform: &domain::Platform,
_req: &PaymentMethodCollectLinkRequest,
) -> RouterResult<PaymentMethodCollectLinkData> {
todo!()
}
#[cfg(feature = "v1")]
pub async fn validate_request_and_initiate_payment_method_collect_link(
state: &SessionState,
platform: &domain::Platform,
req: &PaymentMethodCollectLinkRequest,
) -> RouterResult<PaymentMethodCollectLinkData> {
// Validate customer_id
let db: &dyn StorageInterface = &*state.store;
let customer_id = req.customer_id.clone();
let merchant_id = platform.get_provider().get_account().get_id().clone();
#[cfg(feature = "v1")]
match db
.find_customer_by_customer_id_merchant_id(
&customer_id,
&merchant_id,
platform.get_provider().get_key_store(),
platform.get_provider().get_account().storage_scheme,
)
.await
{
Ok(_) => Ok(()),
Err(err) => {
if err.current_context().is_db_not_found() {
Err(err).change_context(errors::ApiErrorResponse::InvalidRequestData {
message: format!(
"customer [{}] not found for merchant [{:?}]",
customer_id.get_string_repr(),
merchant_id
),
})
} else {
Err(err)
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("database error while finding customer")
}
}
}?;
// Create payment method collect link ID
let pm_collect_link_id = core_utils::get_or_generate_id(
"pm_collect_link_id",
&req.pm_collect_link_id,
"pm_collect_link",
)?;
// Fetch all configs
let default_config = &state.conf.generic_link.payment_method_collect;
#[cfg(feature = "v1")]
let merchant_config = platform
.get_processor()
.get_account()
.pm_collect_link_config
.as_ref()
.map(|config| {
common_utils::ext_traits::ValueExt::parse_value::<admin::BusinessCollectLinkConfig>(
config.clone(),
"BusinessCollectLinkConfig",
)
})
.transpose()
.change_context(errors::ApiErrorResponse::InvalidDataValue {
field_name: "pm_collect_link_config in merchant_account",
})?;
#[cfg(feature = "v2")]
let merchant_config = Option::<admin::BusinessCollectLinkConfig>::None;
let merchant_ui_config = merchant_config.as_ref().map(|c| c.config.ui_config.clone());
let ui_config = req
.ui_config
.as_ref()
.or(merchant_ui_config.as_ref())
.cloned();
// Form data to be injected in the link
let (logo, merchant_name, theme) = match ui_config {
Some(config) => (config.logo, config.merchant_name, config.theme),
_ => (None, None, None),
};
let pm_collect_link_config = link_utils::GenericLinkUiConfig {
logo,
merchant_name,
theme,
};
let client_secret = utils::generate_id(consts::ID_LENGTH, "pm_collect_link_secret");
let domain = merchant_config
.clone()
.and_then(|c| c.config.domain_name)
.map(|domain| format!("https://{domain}"))
.unwrap_or(state.base_url.clone());
let session_expiry = match req.session_expiry {
Some(expiry) => expiry,
None => default_config.expiry,
};
let link = Secret::new(format!(
"{domain}/payment_methods/collect/{}/{pm_collect_link_id}",
merchant_id.get_string_repr()
));
let enabled_payment_methods = match (&req.enabled_payment_methods, &merchant_config) {
(Some(enabled_payment_methods), _) => enabled_payment_methods.clone(),
(None, Some(config)) => config.enabled_payment_methods.clone(),
_ => {
let mut default_enabled_payout_methods: Vec<link_utils::EnabledPaymentMethod> = vec![];
for (payment_method, payment_method_types) in
default_config.enabled_payment_methods.clone().into_iter()
{
let enabled_payment_method = link_utils::EnabledPaymentMethod {
payment_method,
payment_method_types: payment_method_types.into_iter().collect(),
};
default_enabled_payout_methods.push(enabled_payment_method);
}
default_enabled_payout_methods
}
};
Ok(PaymentMethodCollectLinkData {
pm_collect_link_id: pm_collect_link_id.clone(),
customer_id,
link,
client_secret: Secret::new(client_secret),
session_expiry,
ui_config: pm_collect_link_config,
enabled_payment_methods: Some(enabled_payment_methods),
})
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/payment_methods/transformers.rs | crates/router/src/core/payment_methods/transformers.rs | pub use ::payment_methods::controller::{DataDuplicationCheck, DeleteCardResp};
use api_models::payment_methods::Card;
#[cfg(feature = "v2")]
use api_models::{enums as api_enums, payment_methods::PaymentMethodResponseItem};
use common_enums::CardNetwork;
use common_utils::{
ext_traits::{Encode, StringExt},
id_type,
pii::{Email, SecretSerdeValue},
request::RequestContent,
};
use error_stack::ResultExt;
#[cfg(feature = "v2")]
use hyperswitch_domain_models::payment_method_data;
use josekit::jwe;
use router_env::RequestId;
use serde::{Deserialize, Serialize};
use crate::{
configs::settings,
core::{
errors::{self, CustomResult},
payment_methods::cards::call_vault_service,
},
headers,
pii::{prelude::*, Secret},
routes,
services::{api as services, encryption, EncryptionAlgorithm},
types::{api, domain},
utils::OptionExt,
};
#[cfg(feature = "v2")]
use crate::{
consts,
types::{payment_methods as pm_types, transformers},
};
#[derive(Debug, Serialize)]
#[serde(untagged)]
pub enum StoreLockerReq {
LockerCard(StoreCardReq),
LockerGeneric(StoreGenericReq),
}
impl StoreLockerReq {
pub fn update_requestor_card_reference(&mut self, card_reference: Option<String>) {
match self {
Self::LockerCard(c) => c.requestor_card_reference = card_reference,
Self::LockerGeneric(_) => (),
}
}
}
#[derive(Debug, Deserialize, Serialize)]
pub struct StoreCardReq {
pub merchant_id: id_type::MerchantId,
pub merchant_customer_id: id_type::CustomerId,
#[serde(skip_serializing_if = "Option::is_none")]
pub requestor_card_reference: Option<String>,
pub card: Card,
pub ttl: i64,
}
#[derive(Debug, Deserialize, Serialize)]
pub struct StoreGenericReq {
pub merchant_id: id_type::MerchantId,
pub merchant_customer_id: id_type::CustomerId,
#[serde(rename = "enc_card_data")]
pub enc_data: String,
pub ttl: i64,
}
#[derive(Debug, Deserialize, Serialize)]
pub struct StoreCardResp {
pub status: String,
pub error_message: Option<String>,
pub error_code: Option<String>,
pub payload: Option<StoreCardRespPayload>,
}
#[derive(Debug, Deserialize, Serialize)]
pub struct StoreCardRespPayload {
pub card_reference: String,
pub duplication_check: Option<DataDuplicationCheck>,
}
#[derive(Debug, Deserialize, Serialize)]
pub struct CardReqBody {
pub merchant_id: id_type::MerchantId,
pub merchant_customer_id: id_type::CustomerId,
pub card_reference: String,
}
#[cfg(feature = "v2")]
#[derive(Debug, Deserialize, Serialize)]
pub struct CardReqBodyV2 {
pub merchant_id: id_type::MerchantId,
pub merchant_customer_id: String, // Not changing this as it might lead to api contract failure
pub card_reference: String,
}
#[derive(Debug, Deserialize, Serialize)]
pub struct RetrieveCardResp {
pub status: String,
pub error_message: Option<String>,
pub error_code: Option<String>,
pub payload: Option<RetrieveCardRespPayload>,
}
#[derive(Debug, Deserialize, Serialize)]
pub struct RetrieveCardRespPayload {
pub card: Option<Card>,
pub enc_card_data: Option<Secret<String>>,
/// Additional metadata containing PAR, UPT, and other tokens
pub metadata: Option<SecretSerdeValue>,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AddCardRequest {
pub card_number: cards::CardNumber,
pub customer_id: id_type::CustomerId,
pub card_exp_month: Secret<String>,
pub card_exp_year: Secret<String>,
pub merchant_id: id_type::MerchantId,
pub email_address: Option<Email>,
pub name_on_card: Option<Secret<String>>,
pub nickname: Option<String>,
}
#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AddCardResponse {
pub card_id: String,
pub external_id: String,
pub card_fingerprint: Secret<String>,
pub card_global_fingerprint: Secret<String>,
#[serde(rename = "merchant_id")]
pub merchant_id: Option<id_type::MerchantId>,
pub card_number: Option<cards::CardNumber>,
pub card_exp_year: Option<Secret<String>>,
pub card_exp_month: Option<Secret<String>>,
pub name_on_card: Option<Secret<String>>,
pub nickname: Option<String>,
pub customer_id: Option<id_type::CustomerId>,
pub duplicate: Option<bool>,
}
#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AddPaymentMethodResponse {
pub payment_method_id: String,
pub external_id: String,
#[serde(rename = "merchant_id")]
pub merchant_id: Option<id_type::MerchantId>,
pub nickname: Option<String>,
pub customer_id: Option<id_type::CustomerId>,
pub duplicate: Option<bool>,
pub payment_method_data: Secret<String>,
}
#[derive(Debug, Deserialize, Serialize)]
pub struct GetPaymentMethodResponse {
pub payment_method: AddPaymentMethodResponse,
}
#[derive(Debug, Deserialize, Serialize)]
pub struct GetCardResponse {
pub card: AddCardResponse,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct GetCard<'a> {
merchant_id: &'a str,
card_id: &'a str,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct DeleteCardResponse {
pub card_id: Option<String>,
pub external_id: Option<String>,
pub card_isin: Option<Secret<String>>,
pub status: String,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(transparent)]
pub struct PaymentMethodMetadata {
pub payment_method_tokenization: std::collections::HashMap<String, String>,
}
pub fn get_dotted_jwe(jwe: encryption::JweBody) -> String {
let header = jwe.header;
let encryption_key = jwe.encrypted_key;
let iv = jwe.iv;
let encryption_payload = jwe.encrypted_payload;
let tag = jwe.tag;
format!("{header}.{encryption_key}.{iv}.{encryption_payload}.{tag}")
}
pub fn get_dotted_jws(jws: encryption::JwsBody) -> String {
let header = jws.header;
let payload = jws.payload;
let signature = jws.signature;
format!("{header}.{payload}.{signature}")
}
pub async fn get_decrypted_response_payload(
jwekey: &settings::Jwekey,
jwe_body: encryption::JweBody,
decryption_scheme: settings::DecryptionScheme,
) -> CustomResult<String, errors::VaultError> {
let public_key = jwekey.vault_encryption_key.peek().as_bytes();
let private_key = jwekey.vault_private_key.peek().as_bytes();
let jwt = get_dotted_jwe(jwe_body);
let alg = match decryption_scheme {
settings::DecryptionScheme::RsaOaep => jwe::RSA_OAEP,
settings::DecryptionScheme::RsaOaep256 => jwe::RSA_OAEP_256,
};
let jwe_decrypted = encryption::decrypt_jwe(
&jwt,
encryption::KeyIdCheck::SkipKeyIdCheck,
private_key,
alg,
)
.await
.change_context(errors::VaultError::SaveCardFailed)
.attach_printable("Jwe Decryption failed for JweBody for vault")?;
let jws = jwe_decrypted
.parse_struct("JwsBody")
.change_context(errors::VaultError::ResponseDeserializationFailed)?;
let jws_body = get_dotted_jws(jws);
encryption::verify_sign(jws_body, public_key)
.change_context(errors::VaultError::SaveCardFailed)
.attach_printable("Jws Decryption failed for JwsBody for vault")
}
pub async fn get_decrypted_vault_response_payload(
jwekey: &settings::Jwekey,
jwe_body: encryption::JweBody,
decryption_scheme: settings::DecryptionScheme,
) -> CustomResult<String, errors::VaultError> {
let public_key = jwekey.vault_encryption_key.peek().as_bytes();
let private_key = jwekey.vault_private_key.peek().as_bytes();
let jwt = get_dotted_jwe(jwe_body);
let alg = match decryption_scheme {
settings::DecryptionScheme::RsaOaep => jwe::RSA_OAEP,
settings::DecryptionScheme::RsaOaep256 => jwe::RSA_OAEP_256,
};
let jwe_decrypted = encryption::decrypt_jwe(
&jwt,
encryption::KeyIdCheck::SkipKeyIdCheck,
private_key,
alg,
)
.await
.change_context(errors::VaultError::SaveCardFailed)
.attach_printable("Jwe Decryption failed for JweBody for vault")?;
let jws = jwe_decrypted
.parse_struct("JwsBody")
.change_context(errors::VaultError::ResponseDeserializationFailed)?;
let jws_body = get_dotted_jws(jws);
encryption::verify_sign(jws_body, public_key)
.change_context(errors::VaultError::SaveCardFailed)
.attach_printable("Jws Decryption failed for JwsBody for vault")
}
#[cfg(feature = "v2")]
pub async fn create_jwe_body_for_vault(
jwekey: &settings::Jwekey,
jws: &str,
) -> CustomResult<encryption::JweBody, errors::VaultError> {
let jws_payload: Vec<&str> = jws.split('.').collect();
let generate_jws_body = |payload: Vec<&str>| -> Option<encryption::JwsBody> {
Some(encryption::JwsBody {
header: payload.first()?.to_string(),
payload: payload.get(1)?.to_string(),
signature: payload.get(2)?.to_string(),
})
};
let jws_body =
generate_jws_body(jws_payload).ok_or(errors::VaultError::RequestEncryptionFailed)?;
let payload = jws_body
.encode_to_vec()
.change_context(errors::VaultError::RequestEncodingFailed)?;
let public_key = jwekey.vault_encryption_key.peek().as_bytes();
let jwe_encrypted =
encryption::encrypt_jwe(&payload, public_key, EncryptionAlgorithm::A256GCM, None)
.await
.change_context(errors::VaultError::SaveCardFailed)
.attach_printable("Error on jwe encrypt")?;
let jwe_payload: Vec<&str> = jwe_encrypted.split('.').collect();
let generate_jwe_body = |payload: Vec<&str>| -> Option<encryption::JweBody> {
Some(encryption::JweBody {
header: payload.first()?.to_string(),
iv: payload.get(2)?.to_string(),
encrypted_payload: payload.get(3)?.to_string(),
tag: payload.get(4)?.to_string(),
encrypted_key: payload.get(1)?.to_string(),
})
};
let jwe_body =
generate_jwe_body(jwe_payload).ok_or(errors::VaultError::RequestEncodingFailed)?;
Ok(jwe_body)
}
pub async fn mk_vault_req(
jwekey: &settings::Jwekey,
jws: &str,
) -> CustomResult<encryption::JweBody, errors::VaultError> {
let jws_payload: Vec<&str> = jws.split('.').collect();
let generate_jws_body = |payload: Vec<&str>| -> Option<encryption::JwsBody> {
Some(encryption::JwsBody {
header: payload.first()?.to_string(),
payload: payload.get(1)?.to_string(),
signature: payload.get(2)?.to_string(),
})
};
let jws_body = generate_jws_body(jws_payload).ok_or(errors::VaultError::SaveCardFailed)?;
let payload = jws_body
.encode_to_vec()
.change_context(errors::VaultError::SaveCardFailed)?;
let public_key = jwekey.vault_encryption_key.peek().as_bytes();
let jwe_encrypted =
encryption::encrypt_jwe(&payload, public_key, EncryptionAlgorithm::A256GCM, None)
.await
.change_context(errors::VaultError::SaveCardFailed)
.attach_printable("Error on jwe encrypt")?;
let jwe_payload: Vec<&str> = jwe_encrypted.split('.').collect();
let generate_jwe_body = |payload: Vec<&str>| -> Option<encryption::JweBody> {
Some(encryption::JweBody {
header: payload.first()?.to_string(),
iv: payload.get(2)?.to_string(),
encrypted_payload: payload.get(3)?.to_string(),
tag: payload.get(4)?.to_string(),
encrypted_key: payload.get(1)?.to_string(),
})
};
let jwe_body = generate_jwe_body(jwe_payload).ok_or(errors::VaultError::SaveCardFailed)?;
Ok(jwe_body)
}
pub async fn call_vault_api<'a, Req, Res>(
state: &routes::SessionState,
jwekey: &settings::Jwekey,
locker: &settings::Locker,
payload: &'a Req,
endpoint_path: &str,
tenant_id: id_type::TenantId,
request_id: Option<RequestId>,
) -> CustomResult<Res, errors::VaultError>
where
Req: Encode<'a> + Serialize,
Res: serde::de::DeserializeOwned,
{
let encoded_payload = payload
.encode_to_vec()
.change_context(errors::VaultError::RequestEncodingFailed)?;
let private_key = jwekey.vault_private_key.peek().as_bytes();
let jws =
encryption::jws_sign_payload(&encoded_payload, &locker.locker_signing_key_id, private_key)
.await
.change_context(errors::VaultError::RequestEncodingFailed)?;
let jwe_payload = mk_vault_req(jwekey, &jws).await?;
let url = locker.get_host(endpoint_path);
let mut request = services::Request::new(services::Method::Post, &url);
request.add_header(headers::CONTENT_TYPE, "application/json".into());
request.add_header(headers::X_TENANT_ID, tenant_id.get_string_repr().into());
if let Some(req_id) = request_id {
request.add_header(headers::X_REQUEST_ID, req_id.to_string().into());
}
request.set_body(RequestContent::Json(Box::new(jwe_payload)));
let response = call_vault_service::<Res>(state, request, endpoint_path)
.await
.change_context(errors::VaultError::VaultAPIError)?;
Ok(response)
}
#[cfg(all(feature = "v1", feature = "payouts"))]
pub fn mk_add_bank_response_hs(
bank: api::BankPayout,
bank_reference: String,
req: api::PaymentMethodCreate,
merchant_id: &id_type::MerchantId,
) -> api::PaymentMethodResponse {
api::PaymentMethodResponse {
merchant_id: merchant_id.to_owned(),
customer_id: req.customer_id,
payment_method_id: bank_reference,
payment_method: req.payment_method,
payment_method_type: req.payment_method_type,
bank_transfer: Some(bank),
card: None,
metadata: req.metadata,
created: Some(common_utils::date_time::now()),
recurring_enabled: Some(false), // [#256]
installment_payment_enabled: Some(false), // #[#256]
payment_experience: Some(vec![api_models::enums::PaymentExperience::RedirectToUrl]),
last_used_at: Some(common_utils::date_time::now()),
client_secret: None,
}
}
#[cfg(all(feature = "v2", feature = "payouts"))]
pub fn mk_add_bank_response_hs(
_bank: api::BankPayout,
_bank_reference: String,
_req: api::PaymentMethodCreate,
_merchant_id: &id_type::MerchantId,
) -> api::PaymentMethodResponse {
todo!()
}
#[cfg(feature = "v1")]
pub fn mk_add_card_response_hs(
card: api::CardDetail,
card_reference: String,
req: api::PaymentMethodCreate,
merchant_id: &id_type::MerchantId,
) -> api::PaymentMethodResponse {
let card_number = card.card_number.clone();
let last4_digits = card_number.get_last4();
let card_isin = card_number.get_card_isin();
let card = api::CardDetailFromLocker {
scheme: card
.card_network
.clone()
.map(|card_network| card_network.to_string()),
last4_digits: Some(last4_digits),
issuer_country: card.card_issuing_country,
issuer_country_code: card.card_issuing_country_code,
card_number: Some(card.card_number.clone()),
expiry_month: Some(card.card_exp_month.clone()),
expiry_year: Some(card.card_exp_year.clone()),
card_token: None,
card_fingerprint: None,
card_holder_name: card.card_holder_name.clone(),
nick_name: card.nick_name.clone(),
card_isin: Some(card_isin),
card_issuer: card.card_issuer,
card_network: card.card_network,
card_type: card.card_type,
saved_to_locker: true,
};
api::PaymentMethodResponse {
merchant_id: merchant_id.to_owned(),
customer_id: req.customer_id,
payment_method_id: card_reference,
payment_method: req.payment_method,
payment_method_type: req.payment_method_type,
#[cfg(feature = "payouts")]
bank_transfer: None,
card: Some(card),
metadata: req.metadata,
created: Some(common_utils::date_time::now()),
recurring_enabled: Some(false), // [#256]
installment_payment_enabled: Some(false), // #[#256]
payment_experience: Some(vec![api_models::enums::PaymentExperience::RedirectToUrl]),
last_used_at: Some(common_utils::date_time::now()), // [#256]
client_secret: req.client_secret,
}
}
#[cfg(feature = "v2")]
pub fn mk_add_card_response_hs(
card: api::CardDetail,
card_reference: String,
req: api::PaymentMethodCreate,
merchant_id: &id_type::MerchantId,
) -> api::PaymentMethodResponse {
todo!()
}
#[cfg(feature = "v2")]
pub fn generate_pm_vaulting_req_from_update_request(
pm_create: domain::PaymentMethodVaultingData,
pm_update: api::PaymentMethodUpdateData,
) -> domain::PaymentMethodVaultingData {
match (pm_create, pm_update) {
(
domain::PaymentMethodVaultingData::Card(card_create),
api::PaymentMethodUpdateData::Card(update_card),
) => domain::PaymentMethodVaultingData::Card(api::CardDetail {
card_number: card_create.card_number,
card_exp_month: card_create.card_exp_month,
card_exp_year: card_create.card_exp_year,
card_issuing_country: card_create.card_issuing_country,
card_network: card_create.card_network,
card_issuer: card_create.card_issuer,
card_type: card_create.card_type,
card_holder_name: update_card
.card_holder_name
.or(card_create.card_holder_name),
nick_name: update_card.nick_name.or(card_create.nick_name),
card_cvc: None,
}),
_ => todo!(), //todo! - since support for network tokenization is not added PaymentMethodUpdateData. should be handled later.
}
}
#[cfg(feature = "v2")]
pub fn generate_payment_method_response(
payment_method: &domain::PaymentMethod,
single_use_token: &Option<payment_method_data::SingleUsePaymentMethodToken>,
storage_type: Option<common_enums::StorageType>,
customer_id: Option<id_type::GlobalCustomerId>,
) -> errors::RouterResult<api::PaymentMethodResponse> {
let pmd = payment_method
.payment_method_data
.clone()
.map(|data| data.into_inner())
.and_then(|data| match data {
api::PaymentMethodsData::Card(card) => {
Some(api::PaymentMethodResponseData::Card(card.into()))
}
_ => None,
});
let mut connector_tokens = payment_method
.connector_mandate_details
.as_ref()
.and_then(|connector_token_details| connector_token_details.payments.clone())
.map(|payment_token_details| payment_token_details.0)
.map(|payment_token_details| {
payment_token_details
.into_iter()
.map(transformers::ForeignFrom::foreign_from)
.collect::<Vec<_>>()
})
.unwrap_or_default();
if let Some(token) = single_use_token {
let connector_token_single_use = transformers::ForeignFrom::foreign_from(token);
connector_tokens.push(connector_token_single_use);
}
let connector_tokens = if connector_tokens.is_empty() {
None
} else {
Some(connector_tokens)
};
let network_token_pmd = payment_method
.network_token_payment_method_data
.clone()
.map(|data| data.into_inner())
.and_then(|data| match data {
domain::PaymentMethodsData::NetworkToken(token) => {
Some(api::NetworkTokenDetailsPaymentMethod::from(token))
}
_ => None,
});
let network_token = network_token_pmd.map(|pmd| api::NetworkTokenResponse {
payment_method_data: pmd,
});
let resp = api::PaymentMethodResponse {
merchant_id: payment_method.merchant_id.to_owned(),
customer_id,
id: payment_method.id.to_owned(),
payment_method_type: payment_method.get_payment_method_type(),
payment_method_subtype: payment_method.get_payment_method_subtype(),
created: Some(payment_method.created_at),
recurring_enabled: Some(false),
last_used_at: Some(payment_method.last_used_at),
payment_method_data: pmd,
connector_tokens,
network_token,
storage_type,
};
Ok(resp)
}
pub fn mk_get_card_request(
locker: &settings::Locker,
locker_id: &'static str,
card_id: &'static str,
) -> CustomResult<services::Request, errors::VaultError> {
let get_card_req = GetCard {
merchant_id: locker_id,
card_id,
};
let mut url = locker.host.to_owned();
url.push_str("/card/getCard");
let mut request = services::Request::new(services::Method::Post, &url);
request.set_body(RequestContent::FormUrlEncoded(Box::new(get_card_req)));
Ok(request)
}
pub fn mk_get_card_response(card: GetCardResponse) -> errors::RouterResult<Card> {
Ok(Card {
card_number: card.card.card_number.get_required_value("card_number")?,
name_on_card: card.card.name_on_card,
card_exp_month: card
.card
.card_exp_month
.get_required_value("card_exp_month")?,
card_exp_year: card
.card
.card_exp_year
.get_required_value("card_exp_year")?,
card_brand: None,
card_isin: None,
nick_name: card.card.nickname,
})
}
// Need to fix this once we start moving to v2 completion
#[cfg(feature = "v2")]
#[allow(clippy::too_many_arguments)]
pub async fn mk_delete_card_request_hs_by_id(
state: &routes::SessionState,
jwekey: &settings::Jwekey,
locker: &settings::Locker,
id: &String,
merchant_id: &id_type::MerchantId,
card_reference: &str,
tenant_id: id_type::TenantId,
request_id: Option<RequestId>,
) -> CustomResult<DeleteCardResp, errors::VaultError> {
let card_req_body = CardReqBodyV2 {
merchant_id: merchant_id.to_owned(),
merchant_customer_id: id.to_owned(),
card_reference: card_reference.to_owned(),
};
call_vault_api(
state,
jwekey,
locker,
&card_req_body,
consts::LOCKER_DELETE_CARD_PATH,
tenant_id,
request_id,
)
.await
}
pub fn mk_delete_card_response(
response: DeleteCardResponse,
) -> errors::RouterResult<DeleteCardResp> {
Ok(DeleteCardResp {
status: response.status,
error_message: None,
error_code: None,
})
}
#[cfg(feature = "v1")]
pub fn get_card_detail(
pm: &domain::PaymentMethod,
response: Card,
) -> CustomResult<api::CardDetailFromLocker, errors::VaultError> {
let card_number = response.card_number;
let last4_digits = card_number.clone().get_last4();
//fetch form card bin
let card_detail = api::CardDetailFromLocker {
scheme: pm.scheme.to_owned(),
issuer_country: pm.issuer_country.clone(),
last4_digits: Some(last4_digits),
card_number: Some(card_number),
expiry_month: Some(response.card_exp_month),
expiry_year: Some(response.card_exp_year),
card_token: None,
card_fingerprint: None,
card_holder_name: response.name_on_card,
nick_name: response.nick_name.map(Secret::new),
card_isin: None,
card_issuer: None,
issuer_country_code: None,
card_network: None,
card_type: None,
saved_to_locker: true,
};
Ok(card_detail)
}
#[cfg(feature = "v2")]
pub fn get_card_detail(
_pm: &domain::PaymentMethod,
response: Card,
) -> CustomResult<api::CardDetailFromLocker, errors::VaultError> {
let card_number = response.card_number;
let last4_digits = card_number.clone().get_last4();
//fetch form card bin
let card_detail = api::CardDetailFromLocker {
issuer_country: None,
last4_digits: Some(last4_digits),
card_number: Some(card_number),
expiry_month: Some(response.card_exp_month),
expiry_year: Some(response.card_exp_year),
card_fingerprint: None,
card_holder_name: response.name_on_card,
nick_name: response.nick_name.map(Secret::new),
card_isin: None,
card_issuer: None,
card_network: None,
card_type: None,
saved_to_locker: true,
};
Ok(card_detail)
}
//------------------------------------------------TokenizeService------------------------------------------------
#[allow(clippy::too_many_arguments)]
pub fn mk_card_value1(
card_number: cards::CardNumber,
exp_year: String,
exp_month: String,
name_on_card: Option<String>,
nickname: Option<String>,
card_last_four: Option<String>,
card_token: Option<String>,
card_network: Option<CardNetwork>,
) -> CustomResult<String, errors::VaultError> {
let value1 = api::TokenizedCardValue1 {
card_number: card_number.peek().clone(),
exp_year,
exp_month,
name_on_card,
nickname,
card_last_four,
card_token,
card_network,
};
let value1_req = value1
.encode_to_string_of_json()
.change_context(errors::VaultError::FetchCardFailed)?;
Ok(value1_req)
}
pub fn mk_card_value2(
card_security_code: Option<String>,
card_fingerprint: Option<String>,
external_id: Option<String>,
customer_id: Option<id_type::CustomerId>,
payment_method_id: Option<String>,
) -> CustomResult<String, errors::VaultError> {
let value2 = api::TokenizedCardValue2 {
card_security_code,
card_fingerprint,
external_id,
customer_id,
payment_method_id,
};
let value2_req = value2
.encode_to_string_of_json()
.change_context(errors::VaultError::FetchCardFailed)?;
Ok(value2_req)
}
#[cfg(feature = "v2")]
impl transformers::ForeignTryFrom<(domain::PaymentMethod, String)>
for api::CustomerPaymentMethodResponseItem
{
type Error = error_stack::Report<errors::ValidationError>;
fn foreign_try_from(
(item, payment_token): (domain::PaymentMethod, String),
) -> Result<Self, Self::Error> {
// For payment methods that are active we should always have the payment method subtype
let payment_method_subtype =
item.payment_method_subtype
.ok_or(errors::ValidationError::MissingRequiredField {
field_name: "payment_method_subtype".to_string(),
})?;
// For payment methods that are active we should always have the payment method type
let payment_method_type =
item.payment_method_type
.ok_or(errors::ValidationError::MissingRequiredField {
field_name: "payment_method_type".to_string(),
})?;
let payment_method_data = item
.payment_method_data
.map(|payment_method_data| payment_method_data.into_inner())
.map(|payment_method_data| match payment_method_data {
api_models::payment_methods::PaymentMethodsData::Card(
card_details_payment_method,
) => {
let card_details = api::CardDetailFromLocker::from(card_details_payment_method);
api_models::payment_methods::PaymentMethodListData::Card(card_details)
}
api_models::payment_methods::PaymentMethodsData::BankDetails(..) => todo!(),
api_models::payment_methods::PaymentMethodsData::WalletDetails(..) => {
todo!()
}
});
let payment_method_billing = item
.payment_method_billing_address
.clone()
.map(|billing| billing.into_inner())
.map(From::from);
// TODO: check how we can get this field
let recurring_enabled = true;
Ok(Self {
id: item.id,
customer_id: item
.customer_id
.get_required_value("GlobalCustomerId")
.change_context(errors::ValidationError::MissingRequiredField {
field_name: "customer_id".to_string(),
})?,
payment_method_type,
payment_method_subtype,
created: item.created_at,
last_used_at: item.last_used_at,
recurring_enabled,
payment_method_data,
bank: None,
requires_cvv: true,
is_default: false,
billing: payment_method_billing,
payment_token,
})
}
}
#[cfg(feature = "v2")]
impl transformers::ForeignTryFrom<domain::PaymentMethod> for PaymentMethodResponseItem {
type Error = error_stack::Report<errors::ValidationError>;
fn foreign_try_from(item: domain::PaymentMethod) -> Result<Self, Self::Error> {
// For payment methods that are active we should always have the payment method subtype
let payment_method_subtype =
item.payment_method_subtype
.ok_or(errors::ValidationError::MissingRequiredField {
field_name: "payment_method_subtype".to_string(),
})?;
// For payment methods that are active we should always have the payment method type
let payment_method_type =
item.payment_method_type
.ok_or(errors::ValidationError::MissingRequiredField {
field_name: "payment_method_type".to_string(),
})?;
let payment_method_data = item
.payment_method_data
.map(|payment_method_data| payment_method_data.into_inner())
.map(|payment_method_data| match payment_method_data {
api_models::payment_methods::PaymentMethodsData::Card(
card_details_payment_method,
) => {
let card_details = api::CardDetailFromLocker::from(card_details_payment_method);
api_models::payment_methods::PaymentMethodListData::Card(card_details)
}
api_models::payment_methods::PaymentMethodsData::BankDetails(..) => todo!(),
api_models::payment_methods::PaymentMethodsData::WalletDetails(..) => {
todo!()
}
});
let payment_method_billing = item
.payment_method_billing_address
.clone()
.map(|billing| billing.into_inner())
.map(From::from);
let network_token_pmd = item
.network_token_payment_method_data
.clone()
.map(|data| data.into_inner())
.and_then(|data| match data {
domain::PaymentMethodsData::NetworkToken(token) => {
Some(api::NetworkTokenDetailsPaymentMethod::from(token))
}
_ => None,
});
let network_token_resp = network_token_pmd.map(|pmd| api::NetworkTokenResponse {
payment_method_data: pmd,
});
// TODO: check how we can get this field
let recurring_enabled = Some(true);
let psp_tokenization_enabled = item.connector_mandate_details.and_then(|details| {
details.payments.map(|payments| {
payments.values().any(|connector_token_reference| {
connector_token_reference.connector_token_status
== api_enums::ConnectorTokenStatus::Active
})
})
});
Ok(Self {
id: item.id,
customer_id: item
.customer_id
.get_required_value("GlobalCustomerId")
.change_context(errors::ValidationError::MissingRequiredField {
field_name: "customer_id".to_string(),
})?,
payment_method_type,
payment_method_subtype,
created: item.created_at,
last_used_at: item.last_used_at,
recurring_enabled,
payment_method_data,
bank: None,
requires_cvv: true,
is_default: false,
billing: payment_method_billing,
network_tokenization: network_token_resp,
psp_tokenization_enabled: psp_tokenization_enabled.unwrap_or(false),
})
}
}
#[cfg(feature = "v2")]
pub fn generate_payment_method_session_response(
payment_method_session: hyperswitch_domain_models::payment_methods::PaymentMethodSession,
client_secret: Secret<String>,
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | true |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/payment_methods/tokenize.rs | crates/router/src/core/payment_methods/tokenize.rs | use actix_multipart::form::{bytes::Bytes, text::Text, MultipartForm};
use api_models::{enums as api_enums, payment_methods as payment_methods_api};
use cards::CardNumber;
use common_utils::{
crypto::Encryptable,
id_type,
transformers::{ForeignFrom, ForeignTryFrom},
};
use error_stack::{report, ResultExt};
use hyperswitch_domain_models::router_request_types as domain_request_types;
use masking::{ExposeInterface, Secret};
use router_env::logger;
use crate::{
core::payment_methods::{
cards::{add_card_to_vault, create_encrypted_data, tokenize_card_flow},
network_tokenization, transformers as pm_transformers,
},
errors::{self, RouterResult},
services,
types::{api, domain, payment_methods as pm_types},
SessionState,
};
pub mod card_executor;
pub mod payment_method_executor;
pub use card_executor::*;
pub use payment_method_executor::*;
use rdkafka::message::ToBytes;
#[derive(Debug, MultipartForm)]
pub struct CardNetworkTokenizeForm {
#[multipart(limit = "1MB")]
pub file: Bytes,
pub merchant_id: Text<id_type::MerchantId>,
}
pub fn parse_csv(
merchant_id: &id_type::MerchantId,
data: &[u8],
) -> csv::Result<Vec<payment_methods_api::CardNetworkTokenizeRequest>> {
let mut csv_reader = csv::ReaderBuilder::new()
.has_headers(true)
.from_reader(data);
let mut records = Vec::new();
let mut id_counter = 0;
for (i, result) in csv_reader
.deserialize::<domain::CardNetworkTokenizeRecord>()
.enumerate()
{
match result {
Ok(mut record) => {
logger::info!("Parsed Record (line {}): {:?}", i + 1, record);
id_counter += 1;
record.line_number = Some(id_counter);
record.merchant_id = Some(merchant_id.clone());
match payment_methods_api::CardNetworkTokenizeRequest::foreign_try_from(record) {
Ok(record) => {
records.push(record);
}
Err(err) => {
logger::error!("Error parsing line {}: {}", i + 1, err.to_string());
}
}
}
Err(e) => logger::error!("Error parsing line {}: {}", i + 1, e),
}
}
Ok(records)
}
pub fn get_tokenize_card_form_records(
form: CardNetworkTokenizeForm,
) -> Result<
(
id_type::MerchantId,
Vec<payment_methods_api::CardNetworkTokenizeRequest>,
),
errors::ApiErrorResponse,
> {
match parse_csv(&form.merchant_id, form.file.data.to_bytes()) {
Ok(records) => {
logger::info!("Parsed a total of {} records", records.len());
Ok((form.merchant_id.0, records))
}
Err(e) => {
logger::error!("Failed to parse CSV: {:?}", e);
Err(errors::ApiErrorResponse::PreconditionFailed {
message: e.to_string(),
})
}
}
}
pub async fn tokenize_cards(
state: &SessionState,
records: Vec<payment_methods_api::CardNetworkTokenizeRequest>,
provider: &domain::Provider,
) -> errors::RouterResponse<Vec<payment_methods_api::CardNetworkTokenizeResponse>> {
use futures::stream::StreamExt;
// Process all records in parallel
let responses = futures::stream::iter(records.into_iter())
.map(|record| async move {
let tokenize_request = record.data.clone();
let customer = record.customer.clone();
Box::pin(tokenize_card_flow(
state,
domain::CardNetworkTokenizeRequest::foreign_from(record),
provider,
))
.await
.unwrap_or_else(|e| {
let err = e.current_context();
payment_methods_api::CardNetworkTokenizeResponse {
tokenization_data: Some(tokenize_request),
error_code: Some(err.error_code()),
error_message: Some(err.error_message()),
card_tokenized: false,
payment_method_response: None,
customer: Some(customer),
}
})
})
.buffer_unordered(10)
.collect()
.await;
// Return the final response
Ok(services::ApplicationResponse::Json(responses))
}
// Data types
type NetworkTokenizationResponse = (pm_types::CardNetworkTokenResponsePayload, Option<String>);
pub struct StoreLockerResponse {
pub store_card_resp: pm_transformers::StoreCardRespPayload,
pub store_token_resp: pm_transformers::StoreCardRespPayload,
}
// Builder
pub struct NetworkTokenizationBuilder<'a, S: State> {
/// Current state
state: std::marker::PhantomData<S>,
/// Customer details
pub customer: Option<&'a api::CustomerDetails>,
/// Card details
pub card: Option<domain::CardDetail>,
/// CVC
pub card_cvc: Option<Secret<String>>,
/// Network token details
pub network_token: Option<&'a pm_types::CardNetworkTokenResponsePayload>,
/// Stored card details
pub stored_card: Option<&'a pm_transformers::StoreCardRespPayload>,
/// Stored token details
pub stored_token: Option<&'a pm_transformers::StoreCardRespPayload>,
/// Payment method response
pub payment_method_response: Option<api::PaymentMethodResponse>,
/// Card network tokenization status
pub card_tokenized: bool,
/// Error code
pub error_code: Option<&'a String>,
/// Error message
pub error_message: Option<&'a String>,
}
// Async executor
pub struct CardNetworkTokenizeExecutor<'a, D> {
pub state: &'a SessionState,
pub merchant_account: &'a domain::MerchantAccount,
key_store: &'a domain::MerchantKeyStore,
data: &'a D,
customer: &'a domain_request_types::CustomerDetails,
}
// State machine
pub trait State {}
pub trait TransitionTo<S: State> {}
// Trait for network tokenization
#[async_trait::async_trait]
pub trait NetworkTokenizationProcess<'a, D> {
fn new(
state: &'a SessionState,
provider: &'a domain::Provider,
data: &'a D,
customer: &'a domain_request_types::CustomerDetails,
) -> Self;
async fn encrypt_card(
&self,
card_details: &domain::CardDetail,
saved_to_locker: bool,
) -> RouterResult<Encryptable<Secret<serde_json::Value>>>;
async fn encrypt_network_token(
&self,
network_token_details: &NetworkTokenizationResponse,
card_details: &domain::CardDetail,
saved_to_locker: bool,
) -> RouterResult<Encryptable<Secret<serde_json::Value>>>;
async fn fetch_bin_details_and_validate_card_network(
&self,
card_number: CardNumber,
card_issuer: Option<&String>,
card_network: Option<&api_enums::CardNetwork>,
card_type: Option<&api_models::payment_methods::CardType>,
card_issuing_country: Option<&String>,
) -> RouterResult<Option<diesel_models::CardInfo>>;
fn validate_card_network(
&self,
optional_card_network: Option<&api_enums::CardNetwork>,
) -> RouterResult<()>;
async fn tokenize_card(
&self,
customer_id: &id_type::CustomerId,
card: &domain::CardDetail,
optional_cvc: Option<Secret<String>>,
) -> RouterResult<NetworkTokenizationResponse>;
async fn store_network_token_in_locker(
&self,
network_token: &NetworkTokenizationResponse,
customer_id: &id_type::CustomerId,
card_holder_name: Option<Secret<String>>,
nick_name: Option<Secret<String>>,
) -> RouterResult<pm_transformers::StoreCardRespPayload>;
}
// Generic implementation
#[async_trait::async_trait]
impl<'a, D> NetworkTokenizationProcess<'a, D> for CardNetworkTokenizeExecutor<'a, D>
where
D: Send + Sync + 'static,
{
fn new(
state: &'a SessionState,
provider: &'a domain::Provider,
data: &'a D,
customer: &'a domain_request_types::CustomerDetails,
) -> Self {
Self {
data,
customer,
state,
merchant_account: provider.get_account(),
key_store: provider.get_key_store(),
}
}
async fn encrypt_card(
&self,
card_details: &domain::CardDetail,
saved_to_locker: bool,
) -> RouterResult<Encryptable<Secret<serde_json::Value>>> {
let pm_data = api::PaymentMethodsData::Card(api::CardDetailsPaymentMethod {
last4_digits: Some(card_details.card_number.get_last4()),
expiry_month: Some(card_details.card_exp_month.clone()),
expiry_year: Some(card_details.card_exp_year.clone()),
card_isin: Some(card_details.card_number.get_card_isin()),
nick_name: card_details.nick_name.clone(),
card_holder_name: card_details.card_holder_name.clone(),
issuer_country: card_details.card_issuing_country.clone(),
issuer_country_code: card_details.card_issuing_country_code.clone(),
card_issuer: card_details.card_issuer.clone(),
card_network: card_details.card_network.clone(),
card_type: card_details.card_type.clone(),
saved_to_locker,
co_badged_card_data: card_details
.co_badged_card_data
.as_ref()
.map(|data| data.into()),
});
create_encrypted_data(&self.state.into(), self.key_store, pm_data)
.await
.inspect_err(|err| logger::info!("Error encrypting payment method data: {:?}", err))
.change_context(errors::ApiErrorResponse::InternalServerError)
}
async fn encrypt_network_token(
&self,
network_token_details: &NetworkTokenizationResponse,
card_details: &domain::CardDetail,
saved_to_locker: bool,
) -> RouterResult<Encryptable<Secret<serde_json::Value>>> {
let network_token = &network_token_details.0;
let token_data = api::PaymentMethodsData::Card(api::CardDetailsPaymentMethod {
last4_digits: Some(network_token.token_last_four.clone()),
expiry_month: Some(network_token.token_expiry_month.clone()),
expiry_year: Some(network_token.token_expiry_year.clone()),
card_isin: Some(network_token.token_isin.clone()),
nick_name: card_details.nick_name.clone(),
card_holder_name: card_details.card_holder_name.clone(),
issuer_country: card_details.card_issuing_country.clone(),
issuer_country_code: card_details.card_issuing_country_code.clone(),
card_issuer: card_details.card_issuer.clone(),
card_network: card_details.card_network.clone(),
card_type: card_details.card_type.clone(),
saved_to_locker,
co_badged_card_data: None,
});
create_encrypted_data(&self.state.into(), self.key_store, token_data)
.await
.inspect_err(|err| logger::info!("Error encrypting network token data: {:?}", err))
.change_context(errors::ApiErrorResponse::InternalServerError)
}
async fn fetch_bin_details_and_validate_card_network(
&self,
card_number: CardNumber,
card_issuer: Option<&String>,
card_network: Option<&api_enums::CardNetwork>,
card_type: Option<&api_models::payment_methods::CardType>,
card_issuing_country: Option<&String>,
) -> RouterResult<Option<diesel_models::CardInfo>> {
let db = &*self.state.store;
if card_issuer.is_some()
&& card_network.is_some()
&& card_type.is_some()
&& card_issuing_country.is_some()
{
self.validate_card_network(card_network)?;
return Ok(None);
}
db.get_card_info(&card_number.get_card_isin())
.await
.attach_printable("Failed to perform BIN lookup")
.change_context(errors::ApiErrorResponse::InternalServerError)?
.map(|card_info| {
self.validate_card_network(card_info.card_network.as_ref())?;
Ok(card_info)
})
.transpose()
}
async fn tokenize_card(
&self,
customer_id: &id_type::CustomerId,
card: &domain::CardDetail,
optional_cvc: Option<Secret<String>>,
) -> RouterResult<NetworkTokenizationResponse> {
network_tokenization::make_card_network_tokenization_request(
self.state,
card,
optional_cvc,
customer_id,
)
.await
.map_err(|err| {
logger::error!("Failed to tokenize card with the network: {:?}", err);
report!(errors::ApiErrorResponse::InternalServerError)
})
}
fn validate_card_network(
&self,
optional_card_network: Option<&api_enums::CardNetwork>,
) -> RouterResult<()> {
optional_card_network.map_or(
Err(report!(errors::ApiErrorResponse::NotSupported {
message: "Unknown card network".to_string()
})),
|card_network| {
if self
.state
.conf
.network_tokenization_supported_card_networks
.card_networks
.contains(card_network)
{
Ok(())
} else {
Err(report!(errors::ApiErrorResponse::NotSupported {
message: format!(
"Network tokenization for {card_network} is not supported",
)
}))
}
},
)
}
async fn store_network_token_in_locker(
&self,
network_token: &NetworkTokenizationResponse,
customer_id: &id_type::CustomerId,
card_holder_name: Option<Secret<String>>,
nick_name: Option<Secret<String>>,
) -> RouterResult<pm_transformers::StoreCardRespPayload> {
let network_token = &network_token.0;
let merchant_id = self.merchant_account.get_id();
let locker_req =
pm_transformers::StoreLockerReq::LockerCard(pm_transformers::StoreCardReq {
merchant_id: merchant_id.clone(),
merchant_customer_id: customer_id.clone(),
card: payment_methods_api::Card {
card_number: network_token.token.clone(),
card_exp_month: network_token.token_expiry_month.clone(),
card_exp_year: network_token.token_expiry_year.clone(),
card_brand: Some(network_token.card_brand.to_string()),
card_isin: Some(network_token.token_isin.clone()),
name_on_card: card_holder_name,
nick_name: nick_name.map(|nick_name| nick_name.expose()),
},
requestor_card_reference: None,
ttl: self.state.conf.locker.ttl_for_storage_in_secs,
});
let stored_resp = add_card_to_vault(self.state, &locker_req, customer_id)
.await
.inspect_err(|err| logger::info!("Error adding card in locker: {:?}", err))
.change_context(errors::ApiErrorResponse::InternalServerError)?;
Ok(stored_resp)
}
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/payment_methods/batch_retrieve.rs | crates/router/src/core/payment_methods/batch_retrieve.rs | use std::collections::{HashMap, HashSet};
use actix_multipart::form::{bytes::Bytes, text::Text, MultipartForm};
use api_models::payment_methods::{
PaymentMethodsBatchRecord, PaymentMethodsBatchRetrieveResponse, PaymentMethodsData,
};
use common_utils::{ext_traits::ValueExt, id_type};
use error_stack::ResultExt;
use masking::ExposeInterface;
use router_env::logger;
use crate::{
core::errors::{self, RouterResult},
routes,
types::domain,
};
#[derive(Debug, MultipartForm)]
pub struct PaymentMethodsBatchRetrieveForm {
#[multipart(limit = "1MB")]
pub file: Bytes,
pub merchant_id: Text<id_type::MerchantId>,
}
pub fn parse_csv(data: &[u8]) -> csv::Result<Vec<PaymentMethodsBatchRecord>> {
let mut csv_reader = csv::ReaderBuilder::new()
.has_headers(true)
.from_reader(data);
let mut records = Vec::new();
let mut id_counter = 0;
for (line_number, result) in csv_reader
.deserialize::<PaymentMethodsBatchRecord>()
.enumerate()
{
match result {
Ok(mut record) => {
id_counter += 1;
record.line_number = Some(id_counter);
records.push(record);
}
Err(error) => {
logger::error!("Error parsing line {}: {}", line_number + 1, error);
}
}
}
Ok(records)
}
pub fn get_payment_method_batch_records(
form: PaymentMethodsBatchRetrieveForm,
) -> Result<(id_type::MerchantId, Vec<PaymentMethodsBatchRecord>), errors::ApiErrorResponse> {
match parse_csv(form.file.data.as_ref()) {
Ok(records) => {
logger::info!("Parsed a total of {} records", records.len());
Ok((form.merchant_id.0, records))
}
Err(error) => {
logger::error!("Failed to parse CSV: {:?}", error);
Err(errors::ApiErrorResponse::PreconditionFailed {
message: error.to_string(),
})
}
}
}
pub async fn retrieve_payment_method_data(
state: &routes::SessionState,
merchant_id: &id_type::MerchantId,
platform: &domain::Platform,
records: Vec<PaymentMethodsBatchRecord>,
) -> RouterResult<Vec<PaymentMethodsBatchRetrieveResponse>> {
let storage_scheme = platform.get_provider().get_account().storage_scheme;
let mut seen_ids = HashSet::new();
let mut unique_ids = Vec::new();
for record in &records {
if seen_ids.insert(record.payment_method_id.clone()) {
unique_ids.push(record.payment_method_id.clone());
}
}
let payment_methods = if unique_ids.is_empty() {
Vec::new()
} else {
state
.store
.find_payment_methods_by_merchant_id_payment_method_ids(
platform.get_provider().get_key_store(),
merchant_id,
&unique_ids,
storage_scheme,
)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)?
};
let pm_map = payment_methods
.into_iter()
.map(|pm| (pm.payment_method_id.clone(), pm))
.collect::<HashMap<_, _>>();
let responses = records
.into_iter()
.map(|record| {
if let Some(payment_method) = pm_map.get(&record.payment_method_id) {
let mut error_message = None;
let payment_method_data = if let Some(raw_payment_method_data) =
payment_method.payment_method_data.clone()
{
let value = raw_payment_method_data.into_inner().expose();
match value.parse_value::<PaymentMethodsData>("PaymentMethodsData") {
Ok(data) => Some(data),
Err(err) => {
logger::error!("Failed to deserialize payment_method_data: {:?}", err);
error_message =
Some("Failed to deserialize payment_method_data".to_string());
None
}
}
} else {
error_message = Some("payment_method_data not found".to_string());
None
};
PaymentMethodsBatchRetrieveResponse {
payment_method_id: record.payment_method_id,
payment_method_type: payment_method.get_payment_method_type(),
payment_method_subtype: payment_method.get_payment_method_subtype(),
payment_method_data,
error_message,
line_number: record.line_number,
}
} else {
PaymentMethodsBatchRetrieveResponse {
payment_method_id: record.payment_method_id,
payment_method_type: None,
payment_method_subtype: None,
payment_method_data: None,
error_message: Some("Payment method not found".to_string()),
line_number: record.line_number,
}
}
})
.collect();
Ok(responses)
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/payment_methods/cards.rs | crates/router/src/core/payment_methods/cards.rs | use std::{
collections::{HashMap, HashSet},
fmt::Debug,
str::FromStr,
};
use ::payment_methods::{
configs::payment_connector_required_fields::{
get_billing_required_fields, get_shipping_required_fields,
},
controller::PaymentMethodsController,
};
#[cfg(feature = "v1")]
use api_models::admin::PaymentMethodsEnabled;
use api_models::{
enums as api_enums,
payment_methods::{
BankAccountTokenData, Card, CardDetailUpdate, CardDetailsPaymentMethod, CardNetworkTypes,
CountryCodeWithName, ListCountriesCurrenciesRequest, ListCountriesCurrenciesResponse,
LockerCardResponse, MaskedBankDetails, PaymentExperienceTypes, PaymentMethodsData,
RequestPaymentMethodTypes, RequiredFieldInfo, ResponsePaymentMethodIntermediate,
ResponsePaymentMethodTypes, ResponsePaymentMethodsEnabled,
},
payments::BankCodeResponse,
pm_auth::PaymentMethodAuthConfig,
surcharge_decision_configs as api_surcharge_decision_configs,
};
use common_enums::{enums::MerchantStorageScheme, ConnectorType};
use common_utils::{
consts,
crypto::{self, Encryptable},
encryption::Encryption,
ext_traits::{AsyncExt, BytesExt, Encode, StringExt, ValueExt},
generate_id, id_type,
request::Request,
type_name,
types::{
keymanager::{Identifier, KeyManagerState},
MinorUnit,
},
};
use diesel_models::payment_method;
use error_stack::{report, ResultExt};
use euclid::{
dssa::graph::{AnalysisContext, CgraphExt},
frontend::dir,
};
use hyperswitch_constraint_graph as cgraph;
#[cfg(feature = "v1")]
use hyperswitch_domain_models::customer::CustomerUpdate;
use hyperswitch_domain_models::mandates::CommonMandateReference;
use hyperswitch_interfaces::secrets_interface::secret_state::RawSecret;
#[cfg(feature = "v1")]
use kgraph_utils::transformers::IntoDirValue;
use masking::Secret;
use router_env::{instrument, tracing};
use scheduler::errors as sch_errors;
use strum::IntoEnumIterator;
#[cfg(feature = "v1")]
use super::surcharge_decision_configs::{
perform_surcharge_decision_management_for_payment_method_list,
perform_surcharge_decision_management_for_saved_cards,
};
#[cfg(feature = "v1")]
use super::tokenize::NetworkTokenizationProcess;
#[cfg(feature = "v1")]
use crate::core::payment_methods::{
add_payment_method_status_update_task, tokenize,
utils::{get_merchant_pm_filter_graph, make_pm_graph, refresh_pm_filters_cache},
};
#[cfg(feature = "v1")]
use crate::routes::app::SessionStateInfo;
#[cfg(feature = "payouts")]
use crate::types::domain::types::AsyncLift;
use crate::{
configs::settings,
consts as router_consts,
core::{
configs,
errors::{self, StorageErrorExt},
payment_methods::{
network_tokenization, transformers as payment_methods, utils as payment_method_utils,
vault,
},
payments::{
helpers,
routing::{
self,
utils::{load_skip_pre_routing_config, perform_pre_routing},
SessionFlowRoutingInput,
},
},
utils as core_utils,
},
db, logger,
pii::prelude::*,
routes::{self, metrics, payment_methods::ParentPaymentMethodToken},
services,
types::{
api::{self, routing as routing_types, PaymentMethodCreateExt},
domain::{self, Profile},
storage::{self, enums, PaymentMethodListContext, PaymentTokenData},
transformers::{ForeignFrom, ForeignTryFrom},
},
utils,
utils::OptionExt,
};
#[cfg(feature = "v2")]
use crate::{
core::payment_methods as pm_core, headers, types::payment_methods as pm_types,
utils::ConnectorResponseExt,
};
pub struct PmCards<'a> {
pub state: &'a routes::SessionState,
pub provider: &'a domain::Provider,
}
#[async_trait::async_trait]
impl PaymentMethodsController for PmCards<'_> {
#[cfg(feature = "v1")]
#[instrument(skip_all)]
#[allow(clippy::too_many_arguments)]
async fn create_payment_method(
&self,
req: &api::PaymentMethodCreate,
customer_id: &id_type::CustomerId,
payment_method_id: &str,
locker_id: Option<String>,
merchant_id: &id_type::MerchantId,
pm_metadata: Option<serde_json::Value>,
customer_acceptance: Option<serde_json::Value>,
payment_method_data: crypto::OptionalEncryptableValue,
connector_mandate_details: Option<serde_json::Value>,
status: Option<enums::PaymentMethodStatus>,
network_transaction_id: Option<String>,
payment_method_billing_address: crypto::OptionalEncryptableValue,
card_scheme: Option<String>,
network_token_requestor_reference_id: Option<String>,
network_token_locker_id: Option<String>,
network_token_payment_method_data: crypto::OptionalEncryptableValue,
vault_source_details: Option<domain::PaymentMethodVaultSourceDetails>,
) -> errors::CustomResult<domain::PaymentMethod, errors::ApiErrorResponse> {
let db = &*self.state.store;
let customer = db
.find_customer_by_customer_id_merchant_id(
customer_id,
merchant_id,
self.provider.get_key_store(),
self.provider.get_account().storage_scheme,
)
.await
.to_not_found_response(errors::ApiErrorResponse::CustomerNotFound)?;
let client_secret = generate_id(
consts::ID_LENGTH,
format!("{payment_method_id}_secret").as_str(),
);
let current_time = common_utils::date_time::now();
let response = db
.insert_payment_method(
self.provider.get_key_store(),
domain::PaymentMethod {
customer_id: customer_id.to_owned(),
merchant_id: merchant_id.to_owned(),
payment_method_id: payment_method_id.to_string(),
locker_id,
payment_method: req.payment_method,
payment_method_type: req.payment_method_type,
payment_method_issuer: req.payment_method_issuer.clone(),
scheme: req.card_network.clone().or(card_scheme),
metadata: pm_metadata.map(Secret::new),
payment_method_data,
connector_mandate_details,
customer_acceptance: customer_acceptance.map(Secret::new),
client_secret: Some(client_secret),
status: status.unwrap_or(enums::PaymentMethodStatus::Active),
network_transaction_id: network_transaction_id.to_owned(),
payment_method_issuer_code: None,
accepted_currency: None,
token: None,
cardholder_name: None,
issuer_name: None,
issuer_country: None,
payer_country: None,
is_stored: None,
swift_code: None,
direct_debit_token: None,
created_at: current_time,
last_modified: current_time,
last_used_at: current_time,
payment_method_billing_address,
updated_by: None,
version: common_types::consts::API_VERSION,
network_token_requestor_reference_id,
network_token_locker_id,
network_token_payment_method_data,
vault_source_details: vault_source_details
.unwrap_or(domain::PaymentMethodVaultSourceDetails::InternalVault),
created_by: None,
last_modified_by: None,
},
self.provider.get_account().storage_scheme,
)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed to add payment method in db")?;
if customer.default_payment_method_id.is_none() && req.payment_method.is_some() {
let _ = self
.set_default_payment_method(merchant_id, customer_id, payment_method_id.to_owned())
.await
.map_err(|error| {
logger::error!(?error, "Failed to set the payment method as default")
});
}
Ok(response)
}
#[cfg(feature = "v1")]
fn store_default_payment_method(
&self,
req: &api::PaymentMethodCreate,
customer_id: &id_type::CustomerId,
merchant_id: &id_type::MerchantId,
) -> (
api::PaymentMethodResponse,
Option<payment_methods::DataDuplicationCheck>,
) {
let pm_id = generate_id(consts::ID_LENGTH, "pm");
let payment_method_response = api::PaymentMethodResponse {
merchant_id: merchant_id.to_owned(),
customer_id: Some(customer_id.to_owned()),
payment_method_id: pm_id,
payment_method: req.payment_method,
payment_method_type: req.payment_method_type,
#[cfg(feature = "payouts")]
bank_transfer: None,
card: None,
metadata: req.metadata.clone(),
created: Some(common_utils::date_time::now()),
recurring_enabled: Some(false), //[#219]
installment_payment_enabled: Some(false), //[#219]
payment_experience: Some(vec![api_models::enums::PaymentExperience::RedirectToUrl]),
last_used_at: Some(common_utils::date_time::now()),
client_secret: None,
};
(payment_method_response, None)
}
#[cfg(feature = "v2")]
fn store_default_payment_method(
&self,
_req: &api::PaymentMethodCreate,
_customer_id: &id_type::CustomerId,
_merchant_id: &id_type::MerchantId,
) -> (
api::PaymentMethodResponse,
Option<payment_methods::DataDuplicationCheck>,
) {
todo!()
}
#[cfg(feature = "v1")]
#[instrument(skip_all)]
async fn get_or_insert_payment_method(
&self,
req: api::PaymentMethodCreate,
resp: &mut api::PaymentMethodResponse,
customer_id: &id_type::CustomerId,
key_store: &domain::MerchantKeyStore,
) -> errors::RouterResult<domain::PaymentMethod> {
let mut payment_method_id = resp.payment_method_id.clone();
let mut locker_id = None;
let db = &*self.state.store;
let payment_method = {
let existing_pm_by_pmid = db
.find_payment_method(
key_store,
&payment_method_id,
self.provider.get_account().storage_scheme,
)
.await;
if let Err(err) = existing_pm_by_pmid {
if err.current_context().is_db_not_found() {
locker_id = Some(payment_method_id.clone());
let existing_pm_by_locker_id = db
.find_payment_method_by_locker_id(
key_store,
&payment_method_id,
self.provider.get_account().storage_scheme,
)
.await;
match &existing_pm_by_locker_id {
Ok(pm) => payment_method_id.clone_from(pm.get_id()),
Err(_) => payment_method_id = generate_id(consts::ID_LENGTH, "pm"),
};
existing_pm_by_locker_id
} else {
Err(err)
}
} else {
existing_pm_by_pmid
}
};
payment_method_id.clone_into(&mut resp.payment_method_id);
match payment_method {
Ok(pm) => Ok(pm),
Err(err) => {
if err.current_context().is_db_not_found() {
self.insert_payment_method(
resp,
&req,
key_store,
self.provider.get_account().get_id(),
customer_id,
resp.metadata.clone().map(|val| val.expose()),
None,
locker_id,
None,
req.network_transaction_id.clone(),
None,
None,
None,
None,
Default::default(),
)
.await
} else {
Err(err)
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Error while finding payment method")
}
}
}
}
#[cfg(feature = "v2")]
async fn get_or_insert_payment_method(
&self,
_req: api::PaymentMethodCreate,
_resp: &mut api::PaymentMethodResponse,
_customer_id: &id_type::CustomerId,
_key_store: &domain::MerchantKeyStore,
) -> errors::RouterResult<domain::PaymentMethod> {
todo!()
}
#[cfg(feature = "v1")]
#[allow(clippy::too_many_arguments)]
async fn save_network_token_and_update_payment_method(
&self,
req: &api::PaymentMethodMigrate,
key_store: &domain::MerchantKeyStore,
network_token_data: &api_models::payment_methods::MigrateNetworkTokenData,
network_token_requestor_ref_id: String,
pm_id: String,
) -> errors::RouterResult<bool> {
let payment_method_create_request =
api::PaymentMethodCreate::get_payment_method_create_from_payment_method_migrate(
network_token_data.network_token_number.clone(),
req,
);
let customer_id = req.customer_id.clone().get_required_value("customer_id")?;
let network_token_details = api::CardDetail {
card_number: network_token_data.network_token_number.clone(),
card_exp_month: network_token_data.network_token_exp_month.clone(),
card_exp_year: network_token_data.network_token_exp_year.clone(),
card_holder_name: network_token_data.card_holder_name.clone(),
nick_name: network_token_data.nick_name.clone(),
card_issuing_country: network_token_data.card_issuing_country.clone(),
card_issuing_country_code: network_token_data.card_issuing_country_code.clone(),
card_network: network_token_data.card_network.clone(),
card_issuer: network_token_data.card_issuer.clone(),
card_type: network_token_data.card_type.clone(),
card_cvc: None,
};
logger::debug!(
"Adding network token to locker for customer_id: {:?}",
customer_id
);
let token_resp = Box::pin(self.add_card_to_locker(
payment_method_create_request.clone(),
&network_token_details,
&customer_id,
None,
))
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Add Network Token failed");
let key_manager_state = &self.state.into();
match token_resp {
Ok(resp) => {
logger::debug!("Network token added to locker");
let (token_pm_resp, _duplication_check) = resp;
let pm_token_details = token_pm_resp.card.as_ref().map(|card| {
PaymentMethodsData::Card(CardDetailsPaymentMethod::from((card.clone(), None)))
});
let pm_network_token_data_encrypted = pm_token_details
.async_map(|pm_card| {
create_encrypted_data(key_manager_state, key_store, pm_card)
})
.await
.transpose()
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Unable to encrypt payment method data")?;
let pm_update = storage::PaymentMethodUpdate::NetworkTokenDataUpdate {
network_token_requestor_reference_id: Some(network_token_requestor_ref_id),
network_token_locker_id: Some(token_pm_resp.payment_method_id),
network_token_payment_method_data: pm_network_token_data_encrypted
.map(Into::into),
last_modified_by: None,
};
let db = &*self.state.store;
let existing_pm = db
.find_payment_method(
key_store,
&pm_id,
self.provider.get_account().storage_scheme,
)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable(format!(
"Failed to fetch payment method for existing pm_id: {pm_id:?} in db",
))?;
db.update_payment_method(
key_store,
existing_pm,
pm_update,
self.provider.get_account().storage_scheme,
)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable(format!(
"Failed to update payment method for existing pm_id: {pm_id:?} in db",
))?;
logger::debug!("Network token added to locker and payment method updated");
Ok(true)
}
Err(err) => {
logger::debug!("Network token added to locker failed {:?}", err);
Ok(false)
}
}
}
#[cfg(feature = "v1")]
#[allow(clippy::too_many_arguments)]
async fn insert_payment_method(
&self,
resp: &api::PaymentMethodResponse,
req: &api::PaymentMethodCreate,
key_store: &domain::MerchantKeyStore,
merchant_id: &id_type::MerchantId,
customer_id: &id_type::CustomerId,
pm_metadata: Option<serde_json::Value>,
customer_acceptance: Option<serde_json::Value>,
locker_id: Option<String>,
connector_mandate_details: Option<serde_json::Value>,
network_transaction_id: Option<String>,
payment_method_billing_address: crypto::OptionalEncryptableValue,
network_token_requestor_reference_id: Option<String>,
network_token_locker_id: Option<String>,
network_token_payment_method_data: crypto::OptionalEncryptableValue,
vault_source_details: Option<domain::PaymentMethodVaultSourceDetails>,
) -> errors::RouterResult<domain::PaymentMethod> {
let pm_card_details = resp.card.clone().map(|card| {
PaymentMethodsData::Card(CardDetailsPaymentMethod::from((card.clone(), None)))
});
let key_manager_state = self.state.into();
let pm_data_encrypted: crypto::OptionalEncryptableValue = pm_card_details
.clone()
.async_map(|pm_card| create_encrypted_data(&key_manager_state, key_store, pm_card))
.await
.transpose()
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Unable to encrypt payment method data")?;
self.create_payment_method(
req,
customer_id,
&resp.payment_method_id,
locker_id,
merchant_id,
pm_metadata,
customer_acceptance,
pm_data_encrypted,
connector_mandate_details,
None,
network_transaction_id,
payment_method_billing_address,
resp.card.clone().and_then(|card| {
card.card_network
.map(|card_network| card_network.to_string())
}),
network_token_requestor_reference_id,
network_token_locker_id,
network_token_payment_method_data,
vault_source_details,
)
.await
}
#[cfg(feature = "v2")]
#[allow(clippy::too_many_arguments)]
async fn insert_payment_method(
&self,
resp: &api::PaymentMethodResponse,
req: &api::PaymentMethodCreate,
key_store: &domain::MerchantKeyStore,
merchant_id: &id_type::MerchantId,
customer_id: &id_type::CustomerId,
pm_metadata: Option<serde_json::Value>,
customer_acceptance: Option<serde_json::Value>,
locker_id: Option<String>,
connector_mandate_details: Option<serde_json::Value>,
network_transaction_id: Option<String>,
payment_method_billing_address: Option<Encryption>,
) -> errors::RouterResult<domain::PaymentMethod> {
todo!()
}
#[cfg(feature = "payouts")]
async fn add_bank_to_locker(
&self,
req: api::PaymentMethodCreate,
key_store: &domain::MerchantKeyStore,
bank: &api::BankPayout,
customer_id: &id_type::CustomerId,
) -> errors::CustomResult<
(
api::PaymentMethodResponse,
Option<payment_methods::DataDuplicationCheck>,
),
errors::VaultError,
> {
let key = key_store.key.get_inner().peek();
let payout_method_data = api::PayoutMethodData::Bank(bank.clone());
let key_manager_state: KeyManagerState = self.state.into();
let enc_data = async {
serde_json::to_value(payout_method_data.to_owned())
.map_err(|err| {
logger::error!("Error while encoding payout method data: {err:?}");
errors::VaultError::SavePaymentMethodFailed
})
.change_context(errors::VaultError::SavePaymentMethodFailed)
.attach_printable("Unable to encode payout method data")
.ok()
.map(|v| {
let secret: Secret<String> = Secret::new(v.to_string());
secret
})
.async_lift(|inner| async {
domain::types::crypto_operation(
&key_manager_state,
type_name!(payment_method::PaymentMethod),
domain::types::CryptoOperation::EncryptOptional(inner),
Identifier::Merchant(key_store.merchant_id.clone()),
key,
)
.await
.and_then(|val| val.try_into_optionaloperation())
})
.await
}
.await
.change_context(errors::VaultError::SavePaymentMethodFailed)
.attach_printable("Failed to encrypt payout method data")?
.map(Encryption::from)
.map(|e| e.into_inner())
.map_or(Err(errors::VaultError::SavePaymentMethodFailed), |e| {
Ok(hex::encode(e.peek()))
})?;
let payload =
payment_methods::StoreLockerReq::LockerGeneric(payment_methods::StoreGenericReq {
merchant_id: self.provider.get_account().get_id().to_owned(),
merchant_customer_id: customer_id.to_owned(),
enc_data,
ttl: self.state.conf.locker.ttl_for_storage_in_secs,
});
let store_resp = add_card_to_vault(self.state, &payload, customer_id).await?;
let payment_method_resp = payment_methods::mk_add_bank_response_hs(
bank.clone(),
store_resp.card_reference,
req,
self.provider.get_account().get_id(),
);
Ok((payment_method_resp, store_resp.duplication_check))
}
/// The response will be the tuple of PaymentMethodResponse and the duplication check of payment_method
async fn add_card_to_locker(
&self,
req: api::PaymentMethodCreate,
card: &api::CardDetail,
customer_id: &id_type::CustomerId,
card_reference: Option<&str>,
) -> errors::CustomResult<
(
api::PaymentMethodResponse,
Option<payment_methods::DataDuplicationCheck>,
),
errors::VaultError,
> {
metrics::STORED_TO_LOCKER.add(1, &[]);
let add_card_to_hs_resp = Box::pin(common_utils::metrics::utils::record_operation_time(
async {
self.add_card_hs(req.clone(), card, customer_id, card_reference)
.await
.inspect_err(|_| {
metrics::CARD_LOCKER_FAILURES.add(
1,
router_env::metric_attributes!(
("locker", "rust"),
("operation", "add")
),
);
})
},
&metrics::CARD_ADD_TIME,
router_env::metric_attributes!(("locker", "rust")),
))
.await?;
logger::debug!("card added to hyperswitch-card-vault");
Ok(add_card_to_hs_resp)
}
async fn delete_card_from_locker(
&self,
customer_id: &id_type::CustomerId,
merchant_id: &id_type::MerchantId,
card_reference: &str,
) -> errors::RouterResult<payment_methods::DeleteCardResp> {
metrics::DELETE_FROM_LOCKER.add(1, &[]);
common_utils::metrics::utils::record_operation_time(
async move {
delete_card_from_vault(self.state, customer_id, merchant_id, card_reference)
.await
.inspect_err(|_| {
metrics::CARD_LOCKER_FAILURES.add(
1,
router_env::metric_attributes!(
("locker", "rust"),
("operation", "delete")
),
);
})
},
&metrics::CARD_DELETE_TIME,
&[],
)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed while deleting card from locker")
}
#[instrument(skip_all)]
async fn add_card_hs(
&self,
req: api::PaymentMethodCreate,
card: &api::CardDetail,
customer_id: &id_type::CustomerId,
card_reference: Option<&str>,
) -> errors::CustomResult<
(
api::PaymentMethodResponse,
Option<payment_methods::DataDuplicationCheck>,
),
errors::VaultError,
> {
let payload = payment_methods::StoreLockerReq::LockerCard(payment_methods::StoreCardReq {
merchant_id: self.provider.get_account().get_id().to_owned(),
merchant_customer_id: customer_id.to_owned(),
requestor_card_reference: card_reference.map(str::to_string),
card: Card {
card_number: card.card_number.to_owned(),
name_on_card: card.card_holder_name.to_owned(),
card_exp_month: card.card_exp_month.to_owned(),
card_exp_year: card.card_exp_year.to_owned(),
card_brand: card.card_network.as_ref().map(ToString::to_string),
card_isin: None,
nick_name: card.nick_name.as_ref().map(Secret::peek).cloned(),
},
ttl: self.state.conf.locker.ttl_for_storage_in_secs,
});
let store_card_payload = add_card_to_vault(self.state, &payload, customer_id).await?;
let payment_method_resp = payment_methods::mk_add_card_response_hs(
card.clone(),
store_card_payload.card_reference,
req,
self.provider.get_account().get_id(),
);
Ok((payment_method_resp, store_card_payload.duplication_check))
}
#[cfg(feature = "v1")]
async fn get_card_details_with_locker_fallback(
&self,
pm: &domain::PaymentMethod,
) -> errors::RouterResult<Option<api::CardDetailFromLocker>> {
let card_decrypted = pm
.payment_method_data
.clone()
.map(|x| x.into_inner().expose())
.and_then(|v| serde_json::from_value::<PaymentMethodsData>(v).ok())
.and_then(|pmd| match pmd {
PaymentMethodsData::Card(crd) => Some(api::CardDetailFromLocker::from(crd)),
_ => None,
});
Ok(if let Some(mut crd) = card_decrypted {
crd.scheme.clone_from(&pm.scheme);
Some(crd)
} else {
logger::debug!(
"Getting card details from locker as it is not found in payment methods table"
);
Some(get_card_details_from_locker(self.state, pm).await?)
})
}
#[cfg(feature = "v1")]
async fn get_card_details_without_locker_fallback(
&self,
pm: &domain::PaymentMethod,
) -> errors::RouterResult<api::CardDetailFromLocker> {
let card_decrypted = pm
.payment_method_data
.clone()
.map(|x| x.into_inner().expose())
.and_then(|v| serde_json::from_value::<PaymentMethodsData>(v).ok())
.and_then(|pmd| match pmd {
PaymentMethodsData::Card(crd) => Some(api::CardDetailFromLocker::from(crd)),
_ => None,
});
Ok(if let Some(mut crd) = card_decrypted {
crd.scheme.clone_from(&pm.scheme);
crd
} else {
logger::debug!(
"Getting card details from locker as it is not found in payment methods table"
);
get_card_details_from_locker(self.state, pm).await?
})
}
#[cfg(feature = "v1")]
async fn set_default_payment_method(
&self,
merchant_id: &id_type::MerchantId,
customer_id: &id_type::CustomerId,
payment_method_id: String,
) -> errors::RouterResponse<api_models::payment_methods::CustomerDefaultPaymentMethodResponse>
{
let db = &*self.state.store;
// check for the customer
// TODO: customer need not be checked again here, this function can take an optional customer and check for existence of customer based on the optional value
let customer = db
.find_customer_by_customer_id_merchant_id(
customer_id,
merchant_id,
self.provider.get_key_store(),
self.provider.get_account().storage_scheme,
)
.await
.to_not_found_response(errors::ApiErrorResponse::CustomerNotFound)?;
// check for the presence of payment_method
let payment_method = db
.find_payment_method(
self.provider.get_key_store(),
&payment_method_id,
self.provider.get_account().storage_scheme,
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentMethodNotFound)?;
let pm = payment_method
.get_payment_method_type()
.get_required_value("payment_method")?;
utils::when(
&payment_method.customer_id != customer_id
|| payment_method.merchant_id != *merchant_id,
|| {
Err(errors::ApiErrorResponse::PreconditionFailed {
message: "The payment_method_id is not valid".to_string(),
})
},
)?;
utils::when(
Some(payment_method_id.clone()) == customer.default_payment_method_id,
|| {
Err(errors::ApiErrorResponse::PreconditionFailed {
message: "Payment Method is already set as default".to_string(),
})
},
)?;
let customer_id = customer.customer_id.clone();
let customer_update = CustomerUpdate::UpdateDefaultPaymentMethod {
default_payment_method_id: Some(Some(payment_method_id.to_owned())),
last_modified_by: None,
};
// update the db with the default payment method id
let updated_customer_details = db
.update_customer_by_customer_id_merchant_id(
customer_id.to_owned(),
merchant_id.to_owned(),
customer,
customer_update,
self.provider.get_key_store(),
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | true |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/payment_methods/migration.rs | crates/router/src/core/payment_methods/migration.rs | use actix_multipart::form::{self, bytes, text};
use api_models::payment_methods as pm_api;
use common_utils::{errors::CustomResult, id_type};
use csv::Reader;
use error_stack::ResultExt;
use hyperswitch_domain_models::{
api::ApplicationResponse, errors::api_error_response as errors,
payment_methods::PaymentMethodUpdate, platform,
};
use masking::{ExposeInterface, PeekInterface};
use payment_methods::core::migration::MerchantConnectorValidator;
use rdkafka::message::ToBytes;
use router_env::logger;
use crate::{
core::{errors::StorageErrorExt, payment_methods::cards::create_encrypted_data},
routes::SessionState,
};
type PmMigrationResult<T> = CustomResult<ApplicationResponse<T>, errors::ApiErrorResponse>;
#[cfg(feature = "v1")]
pub async fn update_payment_methods(
state: &SessionState,
payment_methods: Vec<pm_api::UpdatePaymentMethodRecord>,
merchant_id: &id_type::MerchantId,
platform: &platform::Platform,
) -> PmMigrationResult<Vec<pm_api::PaymentMethodUpdateResponse>> {
let mut result = Vec::with_capacity(payment_methods.len());
for record in payment_methods {
let update_res =
update_payment_method_record(state, record.clone(), merchant_id, platform).await;
let res = match update_res {
Ok(ApplicationResponse::Json(response)) => Ok(response),
Err(e) => Err(e.to_string()),
_ => Err("Failed to update payment method".to_string()),
};
result.push(pm_api::PaymentMethodUpdateResponse::from((res, record)));
}
Ok(ApplicationResponse::Json(result))
}
#[cfg(feature = "v1")]
pub async fn update_payment_method_record(
state: &SessionState,
req: pm_api::UpdatePaymentMethodRecord,
merchant_id: &id_type::MerchantId,
platform: &platform::Platform,
) -> CustomResult<
ApplicationResponse<pm_api::PaymentMethodRecordUpdateResponse>,
errors::ApiErrorResponse,
> {
use std::collections::HashMap;
use common_enums::enums;
use common_utils::pii;
use hyperswitch_domain_models::mandates::{
CommonMandateReference, PaymentsMandateReference, PaymentsMandateReferenceRecord,
PayoutsMandateReference, PayoutsMandateReferenceRecord,
};
let db = &*state.store;
let payment_method_id = req.payment_method_id.clone();
let network_transaction_id = req.network_transaction_id.clone();
let status = req.status;
let key_manager_state = state.into();
let mut updated_card_expiry = false;
let payment_method = db
.find_payment_method(
platform.get_provider().get_key_store(),
&payment_method_id,
platform.get_provider().get_account().storage_scheme,
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentMethodNotFound)?;
if payment_method.merchant_id != *merchant_id {
return Err(errors::ApiErrorResponse::InvalidRequestData {
message: "Merchant ID in the request does not match the Merchant ID in the payment method record.".to_string(),
}.into());
}
let updated_payment_method_data = match payment_method.payment_method_data.as_ref() {
Some(data) => {
match serde_json::from_value::<pm_api::PaymentMethodsData>(
data.clone().into_inner().expose(),
) {
Ok(pm_api::PaymentMethodsData::Card(mut card_data)) => {
if let Some(new_month) = &req.card_expiry_month {
card_data.expiry_month = Some(new_month.clone());
updated_card_expiry = true;
}
if let Some(new_year) = &req.card_expiry_year {
card_data.expiry_year = Some(new_year.clone());
updated_card_expiry = true;
}
if updated_card_expiry {
Some(
create_encrypted_data(
&key_manager_state,
platform.get_provider().get_key_store(),
pm_api::PaymentMethodsData::Card(card_data),
)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Unable to encrypt payment method data")
.map(Into::into),
)
} else {
None
}
}
_ => None,
}
}
None => None,
}
.transpose()?;
let mca_data_cache = if let Some(merchant_connector_ids) = &req.merchant_connector_ids {
let parsed_mca_ids =
MerchantConnectorValidator::parse_comma_separated_ids(merchant_connector_ids)?;
let mut cache = HashMap::new();
for merchant_connector_id in parsed_mca_ids {
let mca = db
.find_by_merchant_connector_account_merchant_id_merchant_connector_id(
platform.get_processor().get_account().get_id(),
&merchant_connector_id,
platform.get_processor().get_key_store(),
)
.await
.to_not_found_response(
errors::ApiErrorResponse::MerchantConnectorAccountNotFound {
id: merchant_connector_id.get_string_repr().to_string(),
},
)?;
cache.insert(merchant_connector_id, mca);
}
Some(cache)
} else {
None
};
let pm_update = match (
&req.payment_instrument_id,
&req.connector_customer_id,
&mca_data_cache,
) {
// Case: payment_instrument_id (with or without connector_customer_id)
(Some(payment_instrument_id), _, Some(cache)) => {
let mandate_details = payment_method
.get_common_mandate_reference()
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed to deserialize to Payment Mandate Reference ")?;
let mut existing_payments_mandate = mandate_details
.payments
.clone()
.unwrap_or(PaymentsMandateReference(HashMap::new()));
let mut existing_payouts_mandate = mandate_details
.payouts
.clone()
.unwrap_or(PayoutsMandateReference(HashMap::new()));
for (merchant_connector_id, mca) in cache.iter() {
match mca.connector_type {
enums::ConnectorType::PayoutProcessor => {
let new_payout_record = PayoutsMandateReferenceRecord {
transfer_method_id: Some(payment_instrument_id.peek().to_string()),
connector_customer_id: req.connector_customer_id.clone(),
};
if let Some(existing_record) =
existing_payouts_mandate.0.get_mut(merchant_connector_id)
{
if let Some(transfer_method_id) = &new_payout_record.transfer_method_id
{
existing_record.transfer_method_id =
Some(transfer_method_id.clone());
}
// Update connector_customer_id if provided
if req.connector_customer_id.is_some() {
existing_record.connector_customer_id =
req.connector_customer_id.clone();
}
} else {
existing_payouts_mandate
.0
.insert(merchant_connector_id.clone(), new_payout_record);
}
}
_ => {
if let Some(existing_record) =
existing_payments_mandate.0.get_mut(merchant_connector_id)
{
existing_record.connector_mandate_id =
payment_instrument_id.peek().to_string();
// Update connector_customer_id if provided
if req.connector_customer_id.is_some() {
existing_record.connector_customer_id =
req.connector_customer_id.clone();
}
} else {
existing_payments_mandate.0.insert(
merchant_connector_id.clone(),
PaymentsMandateReferenceRecord {
connector_mandate_id: payment_instrument_id.peek().to_string(),
payment_method_type: None,
original_payment_authorized_amount: None,
original_payment_authorized_currency: None,
mandate_metadata: None,
connector_mandate_status: None,
connector_mandate_request_reference_id: None,
connector_customer_id: req.connector_customer_id.clone(),
},
);
}
}
}
}
let updated_connector_mandate_details = CommonMandateReference {
payments: if !existing_payments_mandate.0.is_empty() {
Some(existing_payments_mandate)
} else {
mandate_details.payments
},
payouts: if !existing_payouts_mandate.0.is_empty() {
Some(existing_payouts_mandate)
} else {
mandate_details.payouts
},
};
let connector_mandate_details_value = updated_connector_mandate_details
.get_mandate_details_value()
.map_err(|err| {
logger::error!("Failed to get get_mandate_details_value : {:?}", err);
errors::ApiErrorResponse::MandateUpdateFailed
})?;
PaymentMethodUpdate::PaymentMethodBatchUpdate {
connector_mandate_details: Some(pii::SecretSerdeValue::new(
connector_mandate_details_value,
)),
network_transaction_id,
status,
payment_method_data: updated_payment_method_data.clone(),
last_modified_by: None,
}
}
// Case: Only connector_customer_id provided
(None, Some(connector_customer_id), Some(cache)) => {
let mandate_details = payment_method
.get_common_mandate_reference()
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed to deserialize to Payment Mandate Reference ")?;
// Error if no mandate details exist
if mandate_details.payments.is_none() && mandate_details.payouts.is_none() {
return Err(errors::ApiErrorResponse::InvalidRequestData {
message: "connector_mandate_details does not exist".to_string(),
}
.into());
}
let mut existing_payments_mandate = mandate_details
.payments
.clone()
.unwrap_or(PaymentsMandateReference(HashMap::new()));
let mut existing_payouts_mandate = mandate_details
.payouts
.clone()
.unwrap_or(PayoutsMandateReference(HashMap::new()));
// For each merchant_connector_id, check appropriate reference based on connector_type
for (merchant_connector_id, mca) in cache.iter() {
match mca.connector_type {
enums::ConnectorType::PayoutProcessor => {
// Check if exists in payouts mandate
if let Some(existing_record) =
existing_payouts_mandate.0.get_mut(merchant_connector_id)
{
existing_record.connector_customer_id =
Some(connector_customer_id.clone());
} else {
return Err(errors::ApiErrorResponse::InvalidRequestData {
message: format!("merchant_connector_id {} does not exist in payouts connector_mandate_details", merchant_connector_id.get_string_repr()),
}.into());
}
}
_ => {
// Check if exists in payments mandate
if let Some(existing_record) =
existing_payments_mandate.0.get_mut(merchant_connector_id)
{
existing_record.connector_customer_id =
Some(connector_customer_id.clone());
} else {
return Err(errors::ApiErrorResponse::InvalidRequestData {
message: format!("merchant_connector_id {} does not exist in payments connector_mandate_details", merchant_connector_id.get_string_repr()),
}.into());
}
}
}
}
let updated_connector_mandate_details = CommonMandateReference {
payments: if !existing_payments_mandate.0.is_empty() {
Some(existing_payments_mandate)
} else {
mandate_details.payments
},
payouts: if !existing_payouts_mandate.0.is_empty() {
Some(existing_payouts_mandate)
} else {
mandate_details.payouts
},
};
let connector_mandate_details_value = updated_connector_mandate_details
.get_mandate_details_value()
.map_err(|err| {
logger::error!("Failed to get get_mandate_details_value : {:?}", err);
errors::ApiErrorResponse::MandateUpdateFailed
})?;
PaymentMethodUpdate::PaymentMethodBatchUpdate {
connector_mandate_details: Some(pii::SecretSerdeValue::new(
connector_mandate_details_value,
)),
network_transaction_id,
status,
payment_method_data: updated_payment_method_data.clone(),
last_modified_by: None,
}
}
_ => {
if updated_payment_method_data.is_some() {
PaymentMethodUpdate::PaymentMethodDataUpdate {
payment_method_data: updated_payment_method_data,
last_modified_by: None,
}
} else {
PaymentMethodUpdate::NetworkTransactionIdAndStatusUpdate {
network_transaction_id,
status,
last_modified_by: None,
}
}
}
};
let response = db
.update_payment_method(
platform.get_provider().get_key_store(),
payment_method,
pm_update,
platform.get_provider().get_account().storage_scheme,
)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable(format!(
"Failed to update payment method for existing pm_id: {payment_method_id:?} in db",
))?;
Ok(ApplicationResponse::Json(
pm_api::PaymentMethodRecordUpdateResponse {
payment_method_id: response.payment_method_id,
status: response.status,
network_transaction_id: response.network_transaction_id,
connector_mandate_details: response
.connector_mandate_details
.map(pii::SecretSerdeValue::new),
updated_payment_method_data: Some(updated_card_expiry),
},
))
}
#[derive(Debug, form::MultipartForm)]
pub struct PaymentMethodsUpdateForm {
#[multipart(limit = "1MB")]
pub file: bytes::Bytes,
pub merchant_id: text::Text<id_type::MerchantId>,
}
fn parse_update_csv(data: &[u8]) -> csv::Result<Vec<pm_api::UpdatePaymentMethodRecord>> {
let mut csv_reader = Reader::from_reader(data);
let mut records = Vec::new();
let mut id_counter = 0;
for result in csv_reader.deserialize() {
let mut record: pm_api::UpdatePaymentMethodRecord = result?;
id_counter += 1;
record.line_number = Some(id_counter);
records.push(record);
}
Ok(records)
}
type UpdateValidationResult =
Result<(id_type::MerchantId, Vec<pm_api::UpdatePaymentMethodRecord>), errors::ApiErrorResponse>;
impl PaymentMethodsUpdateForm {
pub fn validate_and_get_payment_method_records(self) -> UpdateValidationResult {
let records = parse_update_csv(self.file.data.to_bytes()).map_err(|e| {
errors::ApiErrorResponse::PreconditionFailed {
message: e.to_string(),
}
})?;
Ok((self.merchant_id.clone(), records))
}
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/payment_methods/surcharge_decision_configs.rs | crates/router/src/core/payment_methods/surcharge_decision_configs.rs | use api_models::{
payment_methods::SurchargeDetailsResponse,
payments, routing,
surcharge_decision_configs::{self, SurchargeDecisionConfigs, SurchargeDecisionManagerRecord},
};
#[cfg(feature = "v1")]
use common_utils::{ext_traits::StringExt, types as common_utils_types};
#[cfg(feature = "v2")]
use common_utils::{
ext_traits::{OptionExt, StringExt},
types as common_utils_types,
};
use error_stack::{self, ResultExt};
use euclid::{
backend,
backend::{inputs as dsl_inputs, EuclidBackend},
};
use router_env::{instrument, logger, tracing};
use serde::{Deserialize, Serialize};
use storage_impl::redis::cache::{self, SURCHARGE_CACHE};
use crate::{
core::{
errors::{self, ConditionalConfigError as ConfigError},
payments::{
conditional_configs::ConditionalConfigResult, routing::make_dsl_input_for_surcharge,
types,
},
},
db::StorageInterface,
types::{
storage::{self, payment_attempt::PaymentAttemptExt},
transformers::ForeignTryFrom,
},
SessionState,
};
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct VirInterpreterBackendCacheWrapper {
cached_algorithm: backend::VirInterpreterBackend<SurchargeDecisionConfigs>,
merchant_surcharge_configs: surcharge_decision_configs::MerchantSurchargeConfigs,
}
impl TryFrom<SurchargeDecisionManagerRecord> for VirInterpreterBackendCacheWrapper {
type Error = error_stack::Report<ConfigError>;
fn try_from(value: SurchargeDecisionManagerRecord) -> Result<Self, Self::Error> {
let cached_algorithm = backend::VirInterpreterBackend::with_program(value.algorithm)
.change_context(ConfigError::DslBackendInitError)
.attach_printable("Error initializing DSL interpreter backend")?;
let merchant_surcharge_configs = value.merchant_surcharge_configs;
Ok(Self {
cached_algorithm,
merchant_surcharge_configs,
})
}
}
enum SurchargeSource {
/// Surcharge will be generated through the surcharge rules
Generate(VirInterpreterBackendCacheWrapper),
/// Surcharge is predefined by the merchant through payment create request
Predetermined(payments::RequestSurchargeDetails),
}
impl SurchargeSource {
pub fn generate_surcharge_details_and_populate_surcharge_metadata(
&self,
backend_input: &backend::BackendInput,
payment_attempt: &storage::PaymentAttempt,
surcharge_metadata_and_key: (&mut types::SurchargeMetadata, types::SurchargeKey),
) -> ConditionalConfigResult<Option<types::SurchargeDetails>> {
match self {
Self::Generate(interpreter) => {
let surcharge_output = execute_dsl_and_get_conditional_config(
backend_input.clone(),
&interpreter.cached_algorithm,
)?;
Ok(surcharge_output
.surcharge_details
.map(|surcharge_details| {
get_surcharge_details_from_surcharge_output(
surcharge_details,
payment_attempt,
)
})
.transpose()?
.inspect(|surcharge_details| {
let (surcharge_metadata, surcharge_key) = surcharge_metadata_and_key;
surcharge_metadata
.insert_surcharge_details(surcharge_key, surcharge_details.clone());
}))
}
Self::Predetermined(request_surcharge_details) => Ok(Some(
types::SurchargeDetails::from((request_surcharge_details, payment_attempt)),
)),
}
}
}
#[cfg(feature = "v2")]
pub async fn perform_surcharge_decision_management_for_payment_method_list(
_state: &SessionState,
_algorithm_ref: routing::RoutingAlgorithmRef,
_payment_attempt: &storage::PaymentAttempt,
_payment_intent: &storage::PaymentIntent,
_billing_address: Option<payments::Address>,
_response_payment_method_types: &mut [api_models::payment_methods::ResponsePaymentMethodsEnabled],
) -> ConditionalConfigResult<(
types::SurchargeMetadata,
surcharge_decision_configs::MerchantSurchargeConfigs,
)> {
todo!()
}
#[cfg(feature = "v1")]
pub async fn perform_surcharge_decision_management_for_payment_method_list(
state: &SessionState,
algorithm_ref: routing::RoutingAlgorithmRef,
payment_attempt: &storage::PaymentAttempt,
payment_intent: &storage::PaymentIntent,
billing_address: Option<hyperswitch_domain_models::address::Address>,
response_payment_method_types: &mut [api_models::payment_methods::ResponsePaymentMethodsEnabled],
) -> ConditionalConfigResult<(
types::SurchargeMetadata,
surcharge_decision_configs::MerchantSurchargeConfigs,
)> {
let mut surcharge_metadata = types::SurchargeMetadata::new(payment_attempt.attempt_id.clone());
let (surcharge_source, merchant_surcharge_configs) = match (
payment_attempt.get_surcharge_details(),
algorithm_ref.surcharge_config_algo_id,
) {
(Some(request_surcharge_details), _) => (
SurchargeSource::Predetermined(request_surcharge_details),
surcharge_decision_configs::MerchantSurchargeConfigs::default(),
),
(None, Some(algorithm_id)) => {
let cached_algo = ensure_algorithm_cached(
&*state.store,
&payment_attempt.merchant_id,
algorithm_id.as_str(),
)
.await?;
let merchant_surcharge_config = cached_algo.merchant_surcharge_configs.clone();
(
SurchargeSource::Generate(cached_algo),
merchant_surcharge_config,
)
}
(None, None) => {
return Ok((
surcharge_metadata,
surcharge_decision_configs::MerchantSurchargeConfigs::default(),
))
}
};
let surcharge_source_log_message = match &surcharge_source {
SurchargeSource::Generate(_) => "Surcharge was calculated through surcharge rules",
SurchargeSource::Predetermined(_) => "Surcharge was sent in payment create request",
};
logger::debug!(payment_method_list_surcharge_source = surcharge_source_log_message);
let mut backend_input =
make_dsl_input_for_surcharge(payment_attempt, payment_intent, billing_address)
.change_context(ConfigError::InputConstructionError)?;
for payment_methods_enabled in response_payment_method_types.iter_mut() {
for payment_method_type_response in
&mut payment_methods_enabled.payment_method_types.iter_mut()
{
let payment_method_type = payment_method_type_response.payment_method_type;
backend_input.payment_method.payment_method_type = Some(payment_method_type);
backend_input.payment_method.payment_method =
Some(payment_methods_enabled.payment_method);
if let Some(card_network_list) = &mut payment_method_type_response.card_networks {
for card_network_type in card_network_list.iter_mut() {
backend_input.payment_method.card_network =
Some(card_network_type.card_network.clone());
let surcharge_details = surcharge_source
.generate_surcharge_details_and_populate_surcharge_metadata(
&backend_input,
payment_attempt,
(
&mut surcharge_metadata,
types::SurchargeKey::PaymentMethodData(
payment_methods_enabled.payment_method,
payment_method_type_response.payment_method_type,
Some(card_network_type.card_network.clone()),
),
),
)?;
card_network_type.surcharge_details = surcharge_details
.map(|surcharge_details| {
SurchargeDetailsResponse::foreign_try_from((
&surcharge_details,
payment_attempt,
))
.change_context(ConfigError::DslExecutionError)
.attach_printable("Error while constructing Surcharge response type")
})
.transpose()?;
}
} else {
let surcharge_details = surcharge_source
.generate_surcharge_details_and_populate_surcharge_metadata(
&backend_input,
payment_attempt,
(
&mut surcharge_metadata,
types::SurchargeKey::PaymentMethodData(
payment_methods_enabled.payment_method,
payment_method_type_response.payment_method_type,
None,
),
),
)?;
payment_method_type_response.surcharge_details = surcharge_details
.map(|surcharge_details| {
SurchargeDetailsResponse::foreign_try_from((
&surcharge_details,
payment_attempt,
))
.change_context(ConfigError::DslExecutionError)
.attach_printable("Error while constructing Surcharge response type")
})
.transpose()?;
}
}
}
Ok((surcharge_metadata, merchant_surcharge_configs))
}
#[cfg(feature = "v1")]
pub async fn perform_surcharge_decision_management_for_session_flow(
state: &SessionState,
algorithm_ref: routing::RoutingAlgorithmRef,
payment_attempt: &storage::PaymentAttempt,
payment_intent: &storage::PaymentIntent,
billing_address: Option<hyperswitch_domain_models::address::Address>,
payment_method_type_list: &Vec<common_enums::PaymentMethodType>,
) -> ConditionalConfigResult<types::SurchargeMetadata> {
let mut surcharge_metadata = types::SurchargeMetadata::new(payment_attempt.attempt_id.clone());
let surcharge_source = match (
payment_attempt.get_surcharge_details(),
algorithm_ref.surcharge_config_algo_id,
) {
(Some(request_surcharge_details), _) => {
SurchargeSource::Predetermined(request_surcharge_details)
}
(None, Some(algorithm_id)) => {
let cached_algo = ensure_algorithm_cached(
&*state.store,
&payment_attempt.merchant_id,
algorithm_id.as_str(),
)
.await?;
SurchargeSource::Generate(cached_algo)
}
(None, None) => return Ok(surcharge_metadata),
};
let mut backend_input =
make_dsl_input_for_surcharge(payment_attempt, payment_intent, billing_address)
.change_context(ConfigError::InputConstructionError)?;
for payment_method_type in payment_method_type_list {
backend_input.payment_method.payment_method_type = Some(*payment_method_type);
// in case of session flow, payment_method will always be wallet
backend_input.payment_method.payment_method = Some(payment_method_type.to_owned().into());
surcharge_source.generate_surcharge_details_and_populate_surcharge_metadata(
&backend_input,
payment_attempt,
(
&mut surcharge_metadata,
types::SurchargeKey::PaymentMethodData(
payment_method_type.to_owned().into(),
*payment_method_type,
None,
),
),
)?;
}
Ok(surcharge_metadata)
}
#[cfg(feature = "v1")]
pub async fn perform_surcharge_decision_management_for_saved_cards(
state: &SessionState,
algorithm_ref: routing::RoutingAlgorithmRef,
payment_attempt: &storage::PaymentAttempt,
payment_intent: &storage::PaymentIntent,
customer_payment_method_list: &mut [api_models::payment_methods::CustomerPaymentMethod],
) -> ConditionalConfigResult<types::SurchargeMetadata> {
let mut surcharge_metadata = types::SurchargeMetadata::new(payment_attempt.attempt_id.clone());
let surcharge_source = match (
payment_attempt.get_surcharge_details(),
algorithm_ref.surcharge_config_algo_id,
) {
(Some(request_surcharge_details), _) => {
SurchargeSource::Predetermined(request_surcharge_details)
}
(None, Some(algorithm_id)) => {
let cached_algo = ensure_algorithm_cached(
&*state.store,
&payment_attempt.merchant_id,
algorithm_id.as_str(),
)
.await?;
SurchargeSource::Generate(cached_algo)
}
(None, None) => return Ok(surcharge_metadata),
};
let surcharge_source_log_message = match &surcharge_source {
SurchargeSource::Generate(_) => "Surcharge was calculated through surcharge rules",
SurchargeSource::Predetermined(_) => "Surcharge was sent in payment create request",
};
logger::debug!(customer_saved_card_list_surcharge_source = surcharge_source_log_message);
let mut backend_input = make_dsl_input_for_surcharge(payment_attempt, payment_intent, None)
.change_context(ConfigError::InputConstructionError)?;
for customer_payment_method in customer_payment_method_list.iter_mut() {
let payment_token = customer_payment_method.payment_token.clone();
backend_input.payment_method.payment_method = Some(customer_payment_method.payment_method);
backend_input.payment_method.payment_method_type =
customer_payment_method.payment_method_type;
let card_network = customer_payment_method
.card
.as_ref()
.and_then(|card| card.scheme.as_ref())
.map(|scheme| {
scheme
.clone()
.parse_enum("CardNetwork")
.change_context(ConfigError::DslExecutionError)
})
.transpose()?;
backend_input.payment_method.card_network = card_network;
let surcharge_details = surcharge_source
.generate_surcharge_details_and_populate_surcharge_metadata(
&backend_input,
payment_attempt,
(
&mut surcharge_metadata,
types::SurchargeKey::Token(payment_token),
),
)?;
customer_payment_method.surcharge_details = surcharge_details
.map(|surcharge_details| {
SurchargeDetailsResponse::foreign_try_from((&surcharge_details, payment_attempt))
.change_context(ConfigError::DslParsingError)
})
.transpose()?;
}
Ok(surcharge_metadata)
}
// TODO: uncomment and resolve compiler error when required
// #[cfg(feature = "v2")]
// pub async fn perform_surcharge_decision_management_for_saved_cards(
// state: &SessionState,
// algorithm_ref: routing::RoutingAlgorithmRef,
// payment_attempt: &storage::PaymentAttempt,
// payment_intent: &storage::PaymentIntent,
// customer_payment_method_list: &mut [api_models::payment_methods::CustomerPaymentMethod],
// ) -> ConditionalConfigResult<types::SurchargeMetadata> {
// // let mut surcharge_metadata = types::SurchargeMetadata::new(payment_attempt.id.clone());
// let mut surcharge_metadata = todo!();
// let surcharge_source = match (
// payment_attempt.get_surcharge_details(),
// algorithm_ref.surcharge_config_algo_id,
// ) {
// (Some(request_surcharge_details), _) => {
// SurchargeSource::Predetermined(request_surcharge_details)
// }
// (None, Some(algorithm_id)) => {
// let cached_algo = ensure_algorithm_cached(
// &*state.store,
// &payment_attempt.merchant_id,
// algorithm_id.as_str(),
// )
// .await?;
// SurchargeSource::Generate(cached_algo)
// }
// (None, None) => return Ok(surcharge_metadata),
// };
// let surcharge_source_log_message = match &surcharge_source {
// SurchargeSource::Generate(_) => "Surcharge was calculated through surcharge rules",
// SurchargeSource::Predetermined(_) => "Surcharge was sent in payment create request",
// };
// logger::debug!(customer_saved_card_list_surcharge_source = surcharge_source_log_message);
// let mut backend_input = make_dsl_input_for_surcharge(payment_attempt, payment_intent, None)
// .change_context(ConfigError::InputConstructionError)?;
// for customer_payment_method in customer_payment_method_list.iter_mut() {
// let payment_token = customer_payment_method
// .payment_token
// .clone()
// .get_required_value("payment_token")
// .change_context(ConfigError::InputConstructionError)?;
// backend_input.payment_method.payment_method =
// Some(customer_payment_method.payment_method_type);
// backend_input.payment_method.payment_method_type =
// customer_payment_method.payment_method_subtype;
// let card_network = match customer_payment_method.payment_method_data.as_ref() {
// Some(api_models::payment_methods::PaymentMethodListData::Card(card)) => {
// card.card_network.clone()
// }
// _ => None,
// };
// backend_input.payment_method.card_network = card_network;
// let surcharge_details = surcharge_source
// .generate_surcharge_details_and_populate_surcharge_metadata(
// &backend_input,
// payment_attempt,
// (
// &mut surcharge_metadata,
// types::SurchargeKey::Token(payment_token),
// ),
// )?;
// customer_payment_method.surcharge_details = surcharge_details
// .map(|surcharge_details| {
// SurchargeDetailsResponse::foreign_try_from((&surcharge_details, payment_attempt))
// .change_context(ConfigError::DslParsingError)
// })
// .transpose()?;
// }
// Ok(surcharge_metadata)
// }
#[cfg(feature = "v2")]
fn get_surcharge_details_from_surcharge_output(
_surcharge_details: surcharge_decision_configs::SurchargeDetailsOutput,
_payment_attempt: &storage::PaymentAttempt,
) -> ConditionalConfigResult<types::SurchargeDetails> {
todo!()
}
#[cfg(feature = "v1")]
fn get_surcharge_details_from_surcharge_output(
surcharge_details: surcharge_decision_configs::SurchargeDetailsOutput,
payment_attempt: &storage::PaymentAttempt,
) -> ConditionalConfigResult<types::SurchargeDetails> {
let surcharge_amount = match surcharge_details.surcharge.clone() {
surcharge_decision_configs::SurchargeOutput::Fixed { amount } => amount,
surcharge_decision_configs::SurchargeOutput::Rate(percentage) => percentage
.apply_and_ceil_result(payment_attempt.net_amount.get_total_amount())
.change_context(ConfigError::DslExecutionError)
.attach_printable("Failed to Calculate surcharge amount by applying percentage")?,
};
let tax_on_surcharge_amount = surcharge_details
.tax_on_surcharge
.clone()
.map(|tax_on_surcharge| {
tax_on_surcharge
.apply_and_ceil_result(surcharge_amount)
.change_context(ConfigError::DslExecutionError)
.attach_printable("Failed to Calculate tax amount")
})
.transpose()?
.unwrap_or_default();
Ok(types::SurchargeDetails {
original_amount: payment_attempt.net_amount.get_order_amount(),
surcharge: match surcharge_details.surcharge {
surcharge_decision_configs::SurchargeOutput::Fixed { amount } => {
common_utils_types::Surcharge::Fixed(amount)
}
surcharge_decision_configs::SurchargeOutput::Rate(percentage) => {
common_utils_types::Surcharge::Rate(percentage)
}
},
tax_on_surcharge: surcharge_details.tax_on_surcharge,
surcharge_amount,
tax_on_surcharge_amount,
})
}
#[instrument(skip_all)]
pub async fn ensure_algorithm_cached(
store: &dyn StorageInterface,
merchant_id: &common_utils::id_type::MerchantId,
algorithm_id: &str,
) -> ConditionalConfigResult<VirInterpreterBackendCacheWrapper> {
let key = merchant_id.get_surcharge_dsk_key();
let value_to_cache = || async {
let config: diesel_models::Config = store.find_config_by_key(algorithm_id).await?;
let record: SurchargeDecisionManagerRecord = config
.config
.parse_struct("Program")
.change_context(errors::StorageError::DeserializationFailed)
.attach_printable("Error parsing routing algorithm from configs")?;
VirInterpreterBackendCacheWrapper::try_from(record)
.change_context(errors::StorageError::ValueNotFound("Program".to_string()))
.attach_printable("Error initializing DSL interpreter backend")
};
let interpreter = cache::get_or_populate_in_memory(
store.get_cache_store().as_ref(),
&key,
value_to_cache,
&SURCHARGE_CACHE,
)
.await
.change_context(ConfigError::CacheMiss)
.attach_printable("Unable to retrieve cached routing algorithm even after refresh")?;
Ok(interpreter)
}
pub fn execute_dsl_and_get_conditional_config(
backend_input: dsl_inputs::BackendInput,
interpreter: &backend::VirInterpreterBackend<SurchargeDecisionConfigs>,
) -> ConditionalConfigResult<SurchargeDecisionConfigs> {
let routing_output = interpreter
.execute(backend_input)
.map(|out| out.connector_selection)
.change_context(ConfigError::DslExecutionError)?;
Ok(routing_output)
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/payment_methods/tokenize/card_executor.rs | crates/router/src/core/payment_methods/tokenize/card_executor.rs | use std::str::FromStr;
use ::payment_methods::{controller::PaymentMethodsController, core::migration};
use api_models::{enums as api_enums, payment_methods as payment_methods_api};
use common_utils::{
consts,
ext_traits::OptionExt,
generate_customer_id_of_default_length, id_type,
pii::Email,
type_name,
types::keymanager::{Identifier, KeyManagerState, ToEncryptable},
};
use error_stack::{report, ResultExt};
use hyperswitch_domain_models::type_encryption::{crypto_operation, CryptoOperation};
use masking::{ExposeInterface, PeekInterface, SwitchStrategy};
use router_env::logger;
use super::{
CardNetworkTokenizeExecutor, NetworkTokenizationBuilder, NetworkTokenizationProcess,
NetworkTokenizationResponse, State, StoreLockerResponse, TransitionTo,
};
use crate::{
core::payment_methods::{
cards::{add_card_to_vault, PmCards},
transformers as pm_transformers,
},
errors::{self, RouterResult},
types::{api, domain},
utils,
};
// Available states for card tokenization
pub struct TokenizeWithCard;
pub struct CardRequestValidated;
pub struct CardDetailsAssigned;
pub struct CustomerAssigned;
pub struct CardTokenized;
pub struct CardStored;
pub struct CardTokenStored;
pub struct PaymentMethodCreated;
impl State for TokenizeWithCard {}
impl State for CustomerAssigned {}
impl State for CardRequestValidated {}
impl State for CardDetailsAssigned {}
impl State for CardTokenized {}
impl State for CardStored {}
impl State for CardTokenStored {}
impl State for PaymentMethodCreated {}
// State transitions for card tokenization
impl TransitionTo<CardRequestValidated> for TokenizeWithCard {}
impl TransitionTo<CardDetailsAssigned> for CardRequestValidated {}
impl TransitionTo<CustomerAssigned> for CardDetailsAssigned {}
impl TransitionTo<CardTokenized> for CustomerAssigned {}
impl TransitionTo<CardTokenStored> for CardTokenized {}
impl TransitionTo<PaymentMethodCreated> for CardTokenStored {}
impl Default for NetworkTokenizationBuilder<'_, TokenizeWithCard> {
fn default() -> Self {
Self::new()
}
}
impl<'a> NetworkTokenizationBuilder<'a, TokenizeWithCard> {
pub fn new() -> Self {
Self {
state: std::marker::PhantomData,
customer: None,
card: None,
card_cvc: None,
network_token: None,
stored_card: None,
stored_token: None,
payment_method_response: None,
card_tokenized: false,
error_code: None,
error_message: None,
}
}
pub fn set_validate_result(self) -> NetworkTokenizationBuilder<'a, CardRequestValidated> {
NetworkTokenizationBuilder {
state: std::marker::PhantomData,
customer: self.customer,
card: self.card,
card_cvc: self.card_cvc,
network_token: self.network_token,
stored_card: self.stored_card,
stored_token: self.stored_token,
payment_method_response: self.payment_method_response,
card_tokenized: self.card_tokenized,
error_code: self.error_code,
error_message: self.error_message,
}
}
}
impl<'a> NetworkTokenizationBuilder<'a, CardRequestValidated> {
pub fn set_card_details(
self,
card_req: &'a domain::TokenizeCardRequest,
optional_card_info: Option<diesel_models::CardInfo>,
) -> NetworkTokenizationBuilder<'a, CardDetailsAssigned> {
let card = domain::CardDetail {
card_number: card_req.raw_card_number.clone(),
card_exp_month: card_req.card_expiry_month.clone(),
card_exp_year: card_req.card_expiry_year.clone(),
bank_code: optional_card_info
.as_ref()
.and_then(|card_info| card_info.bank_code.clone()),
nick_name: card_req.nick_name.clone(),
card_holder_name: card_req.card_holder_name.clone(),
card_issuer: optional_card_info
.as_ref()
.map_or(card_req.card_issuer.clone(), |card_info| {
card_info.card_issuer.clone()
}),
card_network: optional_card_info
.as_ref()
.map_or(card_req.card_network.clone(), |card_info| {
card_info.card_network.clone()
}),
card_type: optional_card_info.as_ref().map_or(
card_req
.card_type
.as_ref()
.map(|card_type| card_type.to_string()),
|card_info| card_info.card_type.clone(),
),
card_issuing_country: optional_card_info
.as_ref()
.map_or(card_req.card_issuing_country.clone(), |card_info| {
card_info.card_issuing_country.clone()
}),
card_issuing_country_code: optional_card_info
.as_ref()
.map_or(card_req.card_issuing_country_code.clone(), |card_info| {
card_info.country_code.clone()
}),
co_badged_card_data: None,
};
NetworkTokenizationBuilder {
state: std::marker::PhantomData,
card: Some(card),
card_cvc: card_req.card_cvc.clone(),
customer: self.customer,
network_token: self.network_token,
stored_card: self.stored_card,
stored_token: self.stored_token,
payment_method_response: self.payment_method_response,
card_tokenized: self.card_tokenized,
error_code: self.error_code,
error_message: self.error_message,
}
}
}
impl<'a> NetworkTokenizationBuilder<'a, CardDetailsAssigned> {
pub fn set_customer(
self,
customer: &'a api::CustomerDetails,
) -> NetworkTokenizationBuilder<'a, CustomerAssigned> {
NetworkTokenizationBuilder {
state: std::marker::PhantomData,
customer: Some(customer),
card: self.card,
card_cvc: self.card_cvc,
network_token: self.network_token,
stored_card: self.stored_card,
stored_token: self.stored_token,
payment_method_response: self.payment_method_response,
card_tokenized: self.card_tokenized,
error_code: self.error_code,
error_message: self.error_message,
}
}
}
impl<'a> NetworkTokenizationBuilder<'a, CustomerAssigned> {
pub fn get_optional_card_and_cvc(
&self,
) -> (Option<domain::CardDetail>, Option<masking::Secret<String>>) {
(self.card.clone(), self.card_cvc.clone())
}
pub fn set_token_details(
self,
network_token: &'a NetworkTokenizationResponse,
) -> NetworkTokenizationBuilder<'a, CardTokenized> {
NetworkTokenizationBuilder {
state: std::marker::PhantomData,
network_token: Some(&network_token.0),
customer: self.customer,
card: self.card,
card_cvc: self.card_cvc,
stored_card: self.stored_card,
stored_token: self.stored_token,
payment_method_response: self.payment_method_response,
card_tokenized: self.card_tokenized,
error_code: self.error_code,
error_message: self.error_message,
}
}
}
impl<'a> NetworkTokenizationBuilder<'a, CardTokenized> {
pub fn set_stored_card_response(
self,
store_card_response: &'a StoreLockerResponse,
) -> NetworkTokenizationBuilder<'a, CardStored> {
NetworkTokenizationBuilder {
state: std::marker::PhantomData,
stored_card: Some(&store_card_response.store_card_resp),
customer: self.customer,
card: self.card,
card_cvc: self.card_cvc,
network_token: self.network_token,
stored_token: self.stored_token,
payment_method_response: self.payment_method_response,
card_tokenized: self.card_tokenized,
error_code: self.error_code,
error_message: self.error_message,
}
}
}
impl<'a> NetworkTokenizationBuilder<'a, CardStored> {
pub fn set_stored_token_response(
self,
store_token_response: &'a StoreLockerResponse,
) -> NetworkTokenizationBuilder<'a, CardTokenStored> {
NetworkTokenizationBuilder {
state: std::marker::PhantomData,
card_tokenized: true,
stored_token: Some(&store_token_response.store_token_resp),
customer: self.customer,
card: self.card,
card_cvc: self.card_cvc,
network_token: self.network_token,
stored_card: self.stored_card,
payment_method_response: self.payment_method_response,
error_code: self.error_code,
error_message: self.error_message,
}
}
}
impl<'a> NetworkTokenizationBuilder<'a, CardTokenStored> {
pub fn set_payment_method_response(
self,
payment_method: &'a domain::PaymentMethod,
) -> NetworkTokenizationBuilder<'a, PaymentMethodCreated> {
let card_detail_from_locker = self.card.as_ref().map(|card| api::CardDetailFromLocker {
scheme: None,
issuer_country: card.card_issuing_country.clone(),
issuer_country_code: card.card_issuing_country_code.clone(),
last4_digits: Some(card.card_number.clone().get_last4()),
card_number: None,
expiry_month: Some(card.card_exp_month.clone().clone()),
expiry_year: Some(card.card_exp_year.clone().clone()),
card_token: None,
card_holder_name: card.card_holder_name.clone(),
card_fingerprint: None,
nick_name: card.nick_name.clone(),
card_network: card.card_network.clone(),
card_isin: Some(card.card_number.clone().get_card_isin()),
card_issuer: card.card_issuer.clone(),
card_type: card.card_type.clone(),
saved_to_locker: true,
});
let payment_method_response = api::PaymentMethodResponse {
merchant_id: payment_method.merchant_id.clone(),
customer_id: Some(payment_method.customer_id.clone()),
payment_method_id: payment_method.payment_method_id.clone(),
payment_method: payment_method.payment_method,
payment_method_type: payment_method.payment_method_type,
card: card_detail_from_locker,
recurring_enabled: Some(true),
installment_payment_enabled: Some(false),
metadata: payment_method.metadata.clone(),
created: Some(payment_method.created_at),
last_used_at: Some(payment_method.last_used_at),
client_secret: payment_method.client_secret.clone(),
bank_transfer: None,
payment_experience: None,
};
NetworkTokenizationBuilder {
state: std::marker::PhantomData,
payment_method_response: Some(payment_method_response),
customer: self.customer,
card: self.card,
card_cvc: self.card_cvc,
network_token: self.network_token,
stored_card: self.stored_card,
stored_token: self.stored_token,
card_tokenized: self.card_tokenized,
error_code: self.error_code,
error_message: self.error_message,
}
}
}
impl NetworkTokenizationBuilder<'_, PaymentMethodCreated> {
pub fn build(self) -> api::CardNetworkTokenizeResponse {
api::CardNetworkTokenizeResponse {
payment_method_response: self.payment_method_response,
customer: self.customer.cloned(),
card_tokenized: self.card_tokenized,
error_code: self.error_code.cloned(),
error_message: self.error_message.cloned(),
// Below field is mutated by caller functions for batched API operations
tokenization_data: None,
}
}
}
// Specific executor for card tokenization
impl CardNetworkTokenizeExecutor<'_, domain::TokenizeCardRequest> {
pub async fn validate_request_and_fetch_optional_customer(
&self,
) -> RouterResult<Option<api::CustomerDetails>> {
// Validate card's expiry
migration::validate_card_expiry(&self.data.card_expiry_month, &self.data.card_expiry_year)?;
// Validate customer ID
let customer_id = self
.customer
.customer_id
.as_ref()
.get_required_value("customer_id")
.change_context(errors::ApiErrorResponse::MissingRequiredField {
field_name: "customer.customer_id",
})?;
// Fetch customer details if present
let db = &*self.state.store;
db.find_customer_optional_by_customer_id_merchant_id(
customer_id,
self.merchant_account.get_id(),
self.key_store,
self.merchant_account.storage_scheme,
)
.await
.inspect_err(|err| logger::info!("Error fetching customer: {:?}", err))
.change_context(errors::ApiErrorResponse::InternalServerError)
.map_or(
// Validate if customer creation is feasible
if self.customer.name.is_some()
|| self.customer.email.is_some()
|| self.customer.phone.is_some()
{
Ok(None)
} else {
Err(report!(errors::ApiErrorResponse::MissingRequiredFields {
field_names: vec!["customer.name", "customer.email", "customer.phone"],
}))
},
// If found, send back CustomerDetails from DB
|optional_customer| {
Ok(optional_customer.map(|customer| api::CustomerDetails {
id: customer.customer_id.clone(),
name: customer.name.clone().map(|name| name.into_inner()),
email: customer.email.clone().map(Email::from),
phone: customer.phone.clone().map(|phone| phone.into_inner()),
phone_country_code: customer.phone_country_code.clone(),
tax_registration_id: customer
.tax_registration_id
.clone()
.map(|tax_registration_id| tax_registration_id.into_inner()),
}))
},
)
}
pub async fn create_customer(&self) -> RouterResult<api::CustomerDetails> {
let db = &*self.state.store;
let customer_id = self
.customer
.customer_id
.as_ref()
.get_required_value("customer_id")
.change_context(errors::ApiErrorResponse::MissingRequiredField {
field_name: "customer_id",
})?;
let key_manager_state: &KeyManagerState = &self.state.into();
let encrypted_data = crypto_operation(
key_manager_state,
type_name!(domain::Customer),
CryptoOperation::BatchEncrypt(domain::FromRequestEncryptableCustomer::to_encryptable(
domain::FromRequestEncryptableCustomer {
name: self.customer.name.clone(),
email: self
.customer
.email
.clone()
.map(|email| email.expose().switch_strategy()),
phone: self.customer.phone.clone(),
tax_registration_id: self.customer.tax_registration_id.clone(),
},
)),
Identifier::Merchant(self.merchant_account.get_id().clone()),
self.key_store.key.get_inner().peek(),
)
.await
.inspect_err(|err| logger::info!("Error encrypting customer: {:?}", err))
.and_then(|val| val.try_into_batchoperation())
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed to encrypt customer")?;
let encryptable_customer =
domain::FromRequestEncryptableCustomer::from_encryptable(encrypted_data)
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed to form EncryptableCustomer")?;
let new_customer_id = generate_customer_id_of_default_length();
let domain_customer = domain::Customer {
customer_id: new_customer_id.clone(),
merchant_id: self.merchant_account.get_id().clone(),
name: encryptable_customer.name,
email: encryptable_customer.email.map(|email| {
utils::Encryptable::new(
email.clone().into_inner().switch_strategy(),
email.into_encrypted(),
)
}),
phone: encryptable_customer.phone,
description: None,
phone_country_code: self.customer.phone_country_code.to_owned(),
metadata: None,
connector_customer: None,
created_at: common_utils::date_time::now(),
modified_at: common_utils::date_time::now(),
address_id: None,
default_payment_method_id: None,
updated_by: None,
version: common_types::consts::API_VERSION,
tax_registration_id: encryptable_customer.tax_registration_id,
// TODO: Populate created_by from authentication context once it is integrated in auth data
created_by: None,
last_modified_by: None, // Same as created_by on creation
};
db.insert_customer(
domain_customer,
self.key_store,
self.merchant_account.storage_scheme,
)
.await
.inspect_err(|err| logger::info!("Error creating a customer: {:?}", err))
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable_lazy(|| {
format!(
"Failed to insert customer [id - {:?}] for merchant [id - {:?}]",
customer_id,
self.merchant_account.get_id()
)
})?;
Ok(api::CustomerDetails {
id: new_customer_id,
name: self.customer.name.clone(),
email: self.customer.email.clone(),
phone: self.customer.phone.clone(),
phone_country_code: self.customer.phone_country_code.clone(),
tax_registration_id: self.customer.tax_registration_id.clone(),
})
}
pub async fn store_card_and_token_in_locker(
&self,
network_token: &NetworkTokenizationResponse,
card: &domain::CardDetail,
customer_id: &id_type::CustomerId,
) -> RouterResult<StoreLockerResponse> {
let stored_card_resp = self.store_card_in_locker(card, customer_id).await?;
let stored_token_resp = self
.store_network_token_in_locker(
network_token,
customer_id,
card.card_holder_name.clone(),
card.nick_name.clone(),
)
.await?;
let store_locker_response = StoreLockerResponse {
store_card_resp: stored_card_resp,
store_token_resp: stored_token_resp,
};
Ok(store_locker_response)
}
pub async fn store_card_in_locker(
&self,
card: &domain::CardDetail,
customer_id: &id_type::CustomerId,
) -> RouterResult<pm_transformers::StoreCardRespPayload> {
let merchant_id = self.merchant_account.get_id();
let locker_req =
pm_transformers::StoreLockerReq::LockerCard(pm_transformers::StoreCardReq {
merchant_id: merchant_id.clone(),
merchant_customer_id: customer_id.clone(),
card: payment_methods_api::Card {
card_number: card.card_number.clone(),
card_exp_month: card.card_exp_month.clone(),
card_exp_year: card.card_exp_year.clone(),
card_isin: Some(card.card_number.get_card_isin().clone()),
name_on_card: card.card_holder_name.clone(),
nick_name: card
.nick_name
.as_ref()
.map(|nick_name| nick_name.clone().expose()),
card_brand: None,
},
requestor_card_reference: None,
ttl: self.state.conf.locker.ttl_for_storage_in_secs,
});
let stored_resp = add_card_to_vault(self.state, &locker_req, customer_id)
.await
.inspect_err(|err| logger::info!("Error adding card in locker: {:?}", err))
.change_context(errors::ApiErrorResponse::InternalServerError)?;
Ok(stored_resp)
}
pub async fn create_payment_method(
&self,
stored_locker_resp: &StoreLockerResponse,
network_token_details: &NetworkTokenizationResponse,
card_details: &domain::CardDetail,
customer_id: &id_type::CustomerId,
) -> RouterResult<domain::PaymentMethod> {
let payment_method_id = common_utils::generate_id(consts::ID_LENGTH, "pm");
// Form encrypted PM data (original card)
let enc_pm_data = self.encrypt_card(card_details, true).await?;
// Form encrypted network token data
let enc_token_data = self
.encrypt_network_token(network_token_details, card_details, true)
.await?;
// Form PM create entry
let payment_method_create = api::PaymentMethodCreate {
payment_method: Some(api_enums::PaymentMethod::Card),
payment_method_type: card_details
.card_type
.as_ref()
.and_then(|card_type| api_enums::PaymentMethodType::from_str(card_type).ok()),
payment_method_issuer: card_details.card_issuer.clone(),
payment_method_issuer_code: None,
card: Some(api::CardDetail {
card_number: card_details.card_number.clone(),
card_exp_month: card_details.card_exp_month.clone(),
card_exp_year: card_details.card_exp_year.clone(),
card_holder_name: card_details.card_holder_name.clone(),
nick_name: card_details.nick_name.clone(),
card_issuing_country: card_details.card_issuing_country.clone(),
card_issuing_country_code: card_details.card_issuing_country_code.clone(),
card_network: card_details.card_network.clone(),
card_issuer: card_details.card_issuer.clone(),
card_type: card_details.card_type.clone(),
card_cvc: None, // DO NOT POPULATE CVC FOR ADDITIONAL PAYMENT METHOD DATA
}),
metadata: None,
customer_id: Some(customer_id.clone()),
card_network: card_details
.card_network
.as_ref()
.map(|network| network.to_string()),
bank_transfer: None,
wallet: None,
client_secret: None,
payment_method_data: None,
billing: None,
connector_mandate_details: None,
network_transaction_id: None,
};
let platform = domain::Platform::new(
self.merchant_account.clone(),
self.key_store.clone(),
self.merchant_account.clone(),
self.key_store.clone(),
None,
);
PmCards {
state: self.state,
provider: platform.get_provider(),
}
.create_payment_method(
&payment_method_create,
customer_id,
&payment_method_id,
Some(stored_locker_resp.store_card_resp.card_reference.clone()),
self.merchant_account.get_id(),
None,
None,
Some(enc_pm_data),
None,
None,
None,
None,
None,
network_token_details.1.clone(),
Some(stored_locker_resp.store_token_resp.card_reference.clone()),
Some(enc_token_data),
Default::default(), // this method is used only for card bulk tokenization, and currently external vault is not supported for this hence passing Default i.e. InternalVault
)
.await
}
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/payment_methods/tokenize/payment_method_executor.rs | crates/router/src/core/payment_methods/tokenize/payment_method_executor.rs | use api_models::enums as api_enums;
use common_utils::{ext_traits::OptionExt, fp_utils::when, pii::Email};
use error_stack::{report, ResultExt};
use masking::Secret;
use router_env::logger;
use super::{
CardNetworkTokenizeExecutor, NetworkTokenizationBuilder, NetworkTokenizationProcess,
NetworkTokenizationResponse, State, TransitionTo,
};
use crate::{
core::payment_methods::transformers as pm_transformers,
errors::{self, RouterResult},
types::{api, domain},
};
// Available states for payment method tokenization
pub struct TokenizeWithPmId;
pub struct PmValidated;
pub struct PmFetched;
pub struct PmAssigned;
pub struct PmTokenized;
pub struct PmTokenStored;
pub struct PmTokenUpdated;
impl State for TokenizeWithPmId {}
impl State for PmValidated {}
impl State for PmFetched {}
impl State for PmAssigned {}
impl State for PmTokenized {}
impl State for PmTokenStored {}
impl State for PmTokenUpdated {}
// State transitions for payment method tokenization
impl TransitionTo<PmFetched> for TokenizeWithPmId {}
impl TransitionTo<PmValidated> for PmFetched {}
impl TransitionTo<PmAssigned> for PmValidated {}
impl TransitionTo<PmTokenized> for PmAssigned {}
impl TransitionTo<PmTokenStored> for PmTokenized {}
impl TransitionTo<PmTokenUpdated> for PmTokenStored {}
impl Default for NetworkTokenizationBuilder<'_, TokenizeWithPmId> {
fn default() -> Self {
Self::new()
}
}
impl<'a> NetworkTokenizationBuilder<'a, TokenizeWithPmId> {
pub fn new() -> Self {
Self {
state: std::marker::PhantomData,
customer: None,
card: None,
card_cvc: None,
network_token: None,
stored_card: None,
stored_token: None,
payment_method_response: None,
card_tokenized: false,
error_code: None,
error_message: None,
}
}
pub fn set_payment_method(
self,
payment_method: &domain::PaymentMethod,
) -> NetworkTokenizationBuilder<'a, PmFetched> {
let payment_method_response = api::PaymentMethodResponse {
merchant_id: payment_method.merchant_id.clone(),
customer_id: Some(payment_method.customer_id.clone()),
payment_method_id: payment_method.payment_method_id.clone(),
payment_method: payment_method.payment_method,
payment_method_type: payment_method.payment_method_type,
recurring_enabled: Some(true),
installment_payment_enabled: Some(false),
metadata: payment_method.metadata.clone(),
created: Some(payment_method.created_at),
last_used_at: Some(payment_method.last_used_at),
client_secret: payment_method.client_secret.clone(),
card: None,
bank_transfer: None,
payment_experience: None,
};
NetworkTokenizationBuilder {
state: std::marker::PhantomData,
payment_method_response: Some(payment_method_response),
customer: self.customer,
card: self.card,
card_cvc: self.card_cvc,
network_token: self.network_token,
stored_card: self.stored_card,
stored_token: self.stored_token,
card_tokenized: self.card_tokenized,
error_code: self.error_code,
error_message: self.error_message,
}
}
}
impl<'a> NetworkTokenizationBuilder<'a, PmFetched> {
pub fn set_validate_result(
self,
customer: &'a api::CustomerDetails,
) -> NetworkTokenizationBuilder<'a, PmValidated> {
NetworkTokenizationBuilder {
state: std::marker::PhantomData,
customer: Some(customer),
card: self.card,
card_cvc: self.card_cvc,
network_token: self.network_token,
stored_card: self.stored_card,
stored_token: self.stored_token,
payment_method_response: self.payment_method_response,
card_tokenized: self.card_tokenized,
error_code: self.error_code,
error_message: self.error_message,
}
}
}
impl<'a> NetworkTokenizationBuilder<'a, PmValidated> {
pub fn set_card_details(
self,
card_from_locker: &'a api_models::payment_methods::Card,
optional_card_info: Option<diesel_models::CardInfo>,
card_cvc: Option<Secret<String>>,
) -> NetworkTokenizationBuilder<'a, PmAssigned> {
let card = domain::CardDetail {
card_number: card_from_locker.card_number.clone(),
card_exp_month: card_from_locker.card_exp_month.clone(),
card_exp_year: card_from_locker.card_exp_year.clone(),
bank_code: optional_card_info
.as_ref()
.and_then(|card_info| card_info.bank_code.clone()),
nick_name: card_from_locker
.nick_name
.as_ref()
.map(|nick_name| Secret::new(nick_name.clone())),
card_holder_name: card_from_locker.name_on_card.clone(),
card_issuer: optional_card_info
.as_ref()
.and_then(|card_info| card_info.card_issuer.clone()),
card_network: optional_card_info
.as_ref()
.and_then(|card_info| card_info.card_network.clone()),
card_type: optional_card_info
.as_ref()
.and_then(|card_info| card_info.card_type.clone()),
card_issuing_country: optional_card_info
.as_ref()
.and_then(|card_info| card_info.card_issuing_country.clone()),
card_issuing_country_code: optional_card_info
.as_ref()
.and_then(|card_info| card_info.country_code.clone()),
co_badged_card_data: None,
};
NetworkTokenizationBuilder {
state: std::marker::PhantomData,
card: Some(card),
card_cvc,
customer: self.customer,
network_token: self.network_token,
stored_card: self.stored_card,
stored_token: self.stored_token,
payment_method_response: self.payment_method_response,
card_tokenized: self.card_tokenized,
error_code: self.error_code,
error_message: self.error_message,
}
}
}
impl<'a> NetworkTokenizationBuilder<'a, PmAssigned> {
pub fn get_optional_card_and_cvc(
&self,
) -> (Option<domain::CardDetail>, Option<Secret<String>>) {
(self.card.clone(), self.card_cvc.clone())
}
pub fn set_token_details(
self,
network_token: &'a NetworkTokenizationResponse,
) -> NetworkTokenizationBuilder<'a, PmTokenized> {
NetworkTokenizationBuilder {
state: std::marker::PhantomData,
network_token: Some(&network_token.0),
card_tokenized: true,
customer: self.customer,
card: self.card,
card_cvc: self.card_cvc,
stored_card: self.stored_card,
stored_token: self.stored_token,
payment_method_response: self.payment_method_response,
error_code: self.error_code,
error_message: self.error_message,
}
}
}
impl<'a> NetworkTokenizationBuilder<'a, PmTokenized> {
pub fn set_stored_token_response(
self,
store_token_response: &'a pm_transformers::StoreCardRespPayload,
) -> NetworkTokenizationBuilder<'a, PmTokenStored> {
NetworkTokenizationBuilder {
state: std::marker::PhantomData,
stored_token: Some(store_token_response),
customer: self.customer,
card: self.card,
card_cvc: self.card_cvc,
network_token: self.network_token,
stored_card: self.stored_card,
payment_method_response: self.payment_method_response,
card_tokenized: self.card_tokenized,
error_code: self.error_code,
error_message: self.error_message,
}
}
}
impl<'a> NetworkTokenizationBuilder<'a, PmTokenStored> {
pub fn set_payment_method(
self,
payment_method: &'a domain::PaymentMethod,
) -> NetworkTokenizationBuilder<'a, PmTokenUpdated> {
let payment_method_response = api::PaymentMethodResponse {
merchant_id: payment_method.merchant_id.clone(),
customer_id: Some(payment_method.customer_id.clone()),
payment_method_id: payment_method.payment_method_id.clone(),
payment_method: payment_method.payment_method,
payment_method_type: payment_method.payment_method_type,
recurring_enabled: Some(true),
installment_payment_enabled: Some(false),
metadata: payment_method.metadata.clone(),
created: Some(payment_method.created_at),
last_used_at: Some(payment_method.last_used_at),
client_secret: payment_method.client_secret.clone(),
card: None,
bank_transfer: None,
payment_experience: None,
};
NetworkTokenizationBuilder {
state: std::marker::PhantomData,
payment_method_response: Some(payment_method_response),
customer: self.customer,
card: self.card,
card_cvc: self.card_cvc,
stored_token: self.stored_token,
network_token: self.network_token,
stored_card: self.stored_card,
card_tokenized: self.card_tokenized,
error_code: self.error_code,
error_message: self.error_message,
}
}
}
impl NetworkTokenizationBuilder<'_, PmTokenUpdated> {
pub fn build(self) -> api::CardNetworkTokenizeResponse {
api::CardNetworkTokenizeResponse {
payment_method_response: self.payment_method_response,
customer: self.customer.cloned(),
card_tokenized: self.card_tokenized,
error_code: self.error_code.cloned(),
error_message: self.error_message.cloned(),
// Below field is mutated by caller functions for batched API operations
tokenization_data: None,
}
}
}
// Specific executor for payment method tokenization
impl CardNetworkTokenizeExecutor<'_, domain::TokenizePaymentMethodRequest> {
pub async fn fetch_payment_method(
&self,
payment_method_id: &str,
) -> RouterResult<domain::PaymentMethod> {
self.state
.store
.find_payment_method(
self.key_store,
payment_method_id,
self.merchant_account.storage_scheme,
)
.await
.map_err(|err| match err.current_context() {
errors::StorageError::DatabaseError(err)
if matches!(
err.current_context(),
diesel_models::errors::DatabaseError::NotFound
) =>
{
report!(errors::ApiErrorResponse::InvalidRequestData {
message: "Invalid payment_method_id".into(),
})
}
errors::StorageError::ValueNotFound(_) => {
report!(errors::ApiErrorResponse::InvalidRequestData {
message: "Invalid payment_method_id".to_string(),
})
}
err => {
logger::info!("Error fetching payment_method: {:?}", err);
report!(errors::ApiErrorResponse::InternalServerError)
}
})
}
pub async fn validate_request_and_locker_reference_and_customer(
&self,
payment_method: &domain::PaymentMethod,
) -> RouterResult<(String, api::CustomerDetails)> {
// Ensure customer ID matches
let customer_id_in_req = self
.customer
.customer_id
.clone()
.get_required_value("customer_id")
.change_context(errors::ApiErrorResponse::MissingRequiredField {
field_name: "customer",
})?;
when(payment_method.customer_id != customer_id_in_req, || {
Err(report!(errors::ApiErrorResponse::InvalidRequestData {
message: "Payment method does not belong to the customer".to_string()
}))
})?;
// Ensure payment method is card
match payment_method.payment_method {
Some(api_enums::PaymentMethod::Card) => Ok(()),
Some(_) => Err(report!(errors::ApiErrorResponse::InvalidRequestData {
message: "Payment method is not card".to_string()
})),
None => Err(report!(errors::ApiErrorResponse::InvalidRequestData {
message: "Payment method is empty".to_string()
})),
}?;
// Ensure card is not tokenized already
when(
payment_method
.network_token_requestor_reference_id
.is_some(),
|| {
Err(report!(errors::ApiErrorResponse::InvalidRequestData {
message: "Card is already tokenized".to_string()
}))
},
)?;
// Ensure locker reference is present
let locker_id = payment_method.locker_id.clone().ok_or(report!(
errors::ApiErrorResponse::InvalidRequestData {
message: "locker_id not found for given payment_method_id".to_string()
}
))?;
// Fetch customer
let db = &*self.state.store;
let customer = db
.find_customer_by_customer_id_merchant_id(
&payment_method.customer_id,
self.merchant_account.get_id(),
self.key_store,
self.merchant_account.storage_scheme,
)
.await
.inspect_err(|err| logger::info!("Error fetching customer: {:?}", err))
.change_context(errors::ApiErrorResponse::InternalServerError)?;
let customer_details = api::CustomerDetails {
id: customer.customer_id.clone(),
name: customer.name.clone().map(|name| name.into_inner()),
email: customer.email.clone().map(Email::from),
phone: customer.phone.clone().map(|phone| phone.into_inner()),
phone_country_code: customer.phone_country_code.clone(),
tax_registration_id: customer
.tax_registration_id
.clone()
.map(|tax_registration_id| tax_registration_id.into_inner()),
};
Ok((locker_id, customer_details))
}
pub async fn update_payment_method(
&self,
store_token_response: &pm_transformers::StoreCardRespPayload,
payment_method: domain::PaymentMethod,
network_token_details: &NetworkTokenizationResponse,
card_details: &domain::CardDetail,
) -> RouterResult<domain::PaymentMethod> {
// Form encrypted network token data
let enc_token_data = self
.encrypt_network_token(network_token_details, card_details, true)
.await?;
// Update payment method
let payment_method_update = diesel_models::PaymentMethodUpdate::NetworkTokenDataUpdate {
network_token_requestor_reference_id: network_token_details.1.clone(),
network_token_locker_id: Some(store_token_response.card_reference.clone()),
network_token_payment_method_data: Some(enc_token_data.into()),
last_modified_by: None,
};
self.state
.store
.update_payment_method(
self.key_store,
payment_method,
payment_method_update,
self.merchant_account.storage_scheme,
)
.await
.inspect_err(|err| logger::info!("Error updating payment method: {:?}", err))
.change_context(errors::ApiErrorResponse::InternalServerError)
}
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/card_testing_guard/utils.rs | crates/router/src/core/card_testing_guard/utils.rs | use error_stack::ResultExt;
use hyperswitch_domain_models::{
card_testing_guard_data::CardTestingGuardData, router_request_types::BrowserInformation,
};
use masking::{PeekInterface, Secret};
use router_env::logger;
use super::errors;
use crate::{
core::{errors::RouterResult, payments::helpers},
routes::SessionState,
services,
types::domain,
utils::crypto::{self, SignMessage},
};
pub async fn validate_card_testing_guard_checks(
state: &SessionState,
#[cfg(feature = "v1")] browser_info: Option<&serde_json::Value>,
#[cfg(feature = "v2")] browser_info: Option<&BrowserInformation>,
card_number: cards::CardNumber,
customer_id: &Option<common_utils::id_type::CustomerId>,
business_profile: &domain::Profile,
) -> RouterResult<Option<CardTestingGuardData>> {
match &business_profile.card_testing_guard_config {
Some(card_testing_guard_config) => {
let fingerprint = generate_fingerprint(card_number, business_profile).await?;
let card_testing_guard_expiry = card_testing_guard_config.card_testing_guard_expiry;
let mut card_ip_blocking_cache_key = String::new();
let mut guest_user_card_blocking_cache_key = String::new();
let mut customer_id_blocking_cache_key = String::new();
if card_testing_guard_config.is_card_ip_blocking_enabled {
if let Some(browser_info) = browser_info {
#[cfg(feature = "v1")]
{
let browser_info =
serde_json::from_value::<BrowserInformation>(browser_info.clone())
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("could not parse browser_info")?;
if let Some(browser_info_ip) = browser_info.ip_address {
card_ip_blocking_cache_key =
helpers::validate_card_ip_blocking_for_business_profile(
state,
browser_info_ip,
fingerprint.clone(),
card_testing_guard_config,
)
.await?;
}
}
#[cfg(feature = "v2")]
{
if let Some(browser_info_ip) = browser_info.ip_address {
card_ip_blocking_cache_key =
helpers::validate_card_ip_blocking_for_business_profile(
state,
browser_info_ip,
fingerprint.clone(),
card_testing_guard_config,
)
.await?;
}
}
}
}
if card_testing_guard_config.is_guest_user_card_blocking_enabled {
guest_user_card_blocking_cache_key =
helpers::validate_guest_user_card_blocking_for_business_profile(
state,
fingerprint.clone(),
customer_id.clone(),
card_testing_guard_config,
)
.await?;
}
if card_testing_guard_config.is_customer_id_blocking_enabled {
if let Some(customer_id) = customer_id.clone() {
customer_id_blocking_cache_key =
helpers::validate_customer_id_blocking_for_business_profile(
state,
customer_id.clone(),
business_profile.get_id(),
card_testing_guard_config,
)
.await?;
}
}
Ok(Some(CardTestingGuardData {
is_card_ip_blocking_enabled: card_testing_guard_config.is_card_ip_blocking_enabled,
card_ip_blocking_cache_key,
is_guest_user_card_blocking_enabled: card_testing_guard_config
.is_guest_user_card_blocking_enabled,
guest_user_card_blocking_cache_key,
is_customer_id_blocking_enabled: card_testing_guard_config
.is_customer_id_blocking_enabled,
customer_id_blocking_cache_key,
card_testing_guard_expiry,
}))
}
None => Ok(None),
}
}
pub async fn generate_fingerprint(
card_number: cards::CardNumber,
business_profile: &domain::Profile,
) -> RouterResult<Secret<String>> {
let card_testing_secret_key = &business_profile.card_testing_secret_key;
match card_testing_secret_key {
Some(card_testing_secret_key) => {
let card_number_fingerprint = crypto::HmacSha512::sign_message(
&crypto::HmacSha512,
card_testing_secret_key.get_inner().peek().as_bytes(),
card_number.clone().get_card_no().as_bytes(),
)
.attach_printable("error in pm fingerprint creation")
.map_or_else(
|err| {
logger::error!(error=?err);
None
},
Some,
)
.map(hex::encode);
card_number_fingerprint.map(Secret::new).ok_or_else(|| {
error_stack::report!(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Error while masking fingerprint")
})
}
None => Err(errors::ApiErrorResponse::InternalServerError)
.attach_printable("card testing secret key not configured")?,
}
}
pub async fn increment_blocked_count_in_cache(
state: &SessionState,
card_testing_guard_data: Option<CardTestingGuardData>,
) -> RouterResult<()> {
if let Some(card_testing_guard_data) = card_testing_guard_data.clone() {
if card_testing_guard_data.is_card_ip_blocking_enabled
&& !card_testing_guard_data
.card_ip_blocking_cache_key
.is_empty()
{
let _ = services::card_testing_guard::increment_blocked_count_in_cache(
state,
&card_testing_guard_data.card_ip_blocking_cache_key,
card_testing_guard_data.card_testing_guard_expiry.into(),
)
.await;
}
if card_testing_guard_data.is_guest_user_card_blocking_enabled
&& !card_testing_guard_data
.guest_user_card_blocking_cache_key
.is_empty()
{
let _ = services::card_testing_guard::increment_blocked_count_in_cache(
state,
&card_testing_guard_data.guest_user_card_blocking_cache_key,
card_testing_guard_data.card_testing_guard_expiry.into(),
)
.await;
}
if card_testing_guard_data.is_customer_id_blocking_enabled
&& !card_testing_guard_data
.customer_id_blocking_cache_key
.is_empty()
{
let _ = services::card_testing_guard::increment_blocked_count_in_cache(
state,
&card_testing_guard_data.customer_id_blocking_cache_key,
card_testing_guard_data.card_testing_guard_expiry.into(),
)
.await;
}
}
Ok(())
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/connector_onboarding/paypal.rs | crates/router/src/core/connector_onboarding/paypal.rs | use api_models::{admin::MerchantConnectorUpdate, connector_onboarding as api};
use common_utils::ext_traits::Encode;
use error_stack::ResultExt;
pub use external_services::http_client;
use masking::{ExposeInterface, PeekInterface, Secret};
use crate::{
core::{
admin,
errors::{ApiErrorResponse, RouterResult},
},
services::{ApplicationResponse, Request},
types::{self as oss_types, api as oss_api_types, api::connector_onboarding as types},
utils::connector_onboarding as utils,
SessionState,
};
fn build_referral_url(state: SessionState) -> String {
format!(
"{}v2/customer/partner-referrals",
state.conf.connectors.paypal.base_url
)
}
async fn build_referral_request(
state: SessionState,
tracking_id: String,
return_url: String,
) -> RouterResult<Request> {
let access_token = utils::paypal::generate_access_token(state.clone()).await?;
let request_body = types::paypal::PartnerReferralRequest::new(tracking_id, return_url);
utils::paypal::build_paypal_post_request(
build_referral_url(state),
request_body,
access_token.token.expose(),
)
}
pub async fn get_action_url_from_paypal(
state: SessionState,
tracking_id: String,
return_url: String,
) -> RouterResult<String> {
let referral_request = Box::pin(build_referral_request(
state.clone(),
tracking_id,
return_url,
))
.await?;
let referral_response = http_client::send_request(&state.conf.proxy, referral_request, None)
.await
.change_context(ApiErrorResponse::InternalServerError)
.attach_printable("Failed to send request to paypal referrals")?;
let parsed_response: types::paypal::PartnerReferralResponse = referral_response
.json()
.await
.change_context(ApiErrorResponse::InternalServerError)
.attach_printable("Failed to parse paypal response")?;
parsed_response.extract_action_url()
}
fn merchant_onboarding_status_url(state: SessionState, tracking_id: String) -> String {
let partner_id = state
.conf
.connector_onboarding
.get_inner()
.paypal
.partner_id
.to_owned();
format!(
"{}v1/customer/partners/{}/merchant-integrations?tracking_id={}",
state.conf.connectors.paypal.base_url,
partner_id.expose(),
tracking_id
)
}
pub async fn sync_merchant_onboarding_status(
state: SessionState,
tracking_id: String,
) -> RouterResult<api::OnboardingStatus> {
let access_token = utils::paypal::generate_access_token(state.clone()).await?;
let Some(seller_status_response) =
find_paypal_merchant_by_tracking_id(state.clone(), tracking_id, &access_token).await?
else {
return Ok(api::OnboardingStatus::PayPal(
api::PayPalOnboardingStatus::AccountNotFound,
));
};
let merchant_details_url = seller_status_response
.extract_merchant_details_url(&state.conf.connectors.paypal.base_url)?;
let merchant_details_request =
utils::paypal::build_paypal_get_request(merchant_details_url, access_token.token.expose())?;
let merchant_details_response =
http_client::send_request(&state.conf.proxy, merchant_details_request, None)
.await
.change_context(ApiErrorResponse::InternalServerError)
.attach_printable("Failed to send request to paypal merchant details")?;
let parsed_response: types::paypal::SellerStatusDetailsResponse = merchant_details_response
.json()
.await
.change_context(ApiErrorResponse::InternalServerError)
.attach_printable("Failed to parse paypal merchant details response")?;
let eligibity = parsed_response.get_eligibility_status().await?;
Ok(api::OnboardingStatus::PayPal(eligibity))
}
async fn find_paypal_merchant_by_tracking_id(
state: SessionState,
tracking_id: String,
access_token: &oss_types::AccessToken,
) -> RouterResult<Option<types::paypal::SellerStatusResponse>> {
let seller_status_request = utils::paypal::build_paypal_get_request(
merchant_onboarding_status_url(state.clone(), tracking_id),
access_token.token.peek().to_string(),
)?;
let seller_status_response =
http_client::send_request(&state.conf.proxy, seller_status_request, None)
.await
.change_context(ApiErrorResponse::InternalServerError)
.attach_printable("Failed to send request to paypal onboarding status")?;
if seller_status_response.status().is_success() {
return Ok(Some(
seller_status_response
.json()
.await
.change_context(ApiErrorResponse::InternalServerError)
.attach_printable("Failed to parse paypal onboarding status response")?,
));
}
Ok(None)
}
pub async fn update_mca(
state: &SessionState,
merchant_id: common_utils::id_type::MerchantId,
connector_id: common_utils::id_type::MerchantConnectorAccountId,
auth_details: oss_types::ConnectorAuthType,
) -> RouterResult<oss_api_types::MerchantConnectorResponse> {
let connector_auth_json = auth_details
.encode_to_value()
.change_context(ApiErrorResponse::InternalServerError)
.attach_printable("Error while deserializing connector_account_details")?;
#[cfg(feature = "v1")]
let request = MerchantConnectorUpdate {
connector_type: common_enums::ConnectorType::PaymentProcessor,
connector_account_details: Some(Secret::new(connector_auth_json)),
disabled: Some(false),
status: Some(common_enums::ConnectorStatus::Active),
connector_label: None,
payment_methods_enabled: None,
metadata: None,
frm_configs: None,
connector_webhook_details: None,
pm_auth_config: None,
test_mode: None,
additional_merchant_data: None,
connector_wallets_details: None,
};
#[cfg(feature = "v2")]
let request = MerchantConnectorUpdate {
connector_type: common_enums::ConnectorType::PaymentProcessor,
connector_account_details: Some(Secret::new(connector_auth_json)),
disabled: Some(false),
status: Some(common_enums::ConnectorStatus::Active),
connector_label: None,
payment_methods_enabled: None,
metadata: None,
frm_configs: None,
connector_webhook_details: None,
pm_auth_config: None,
merchant_id: merchant_id.clone(),
additional_merchant_data: None,
connector_wallets_details: None,
feature_metadata: None,
};
let mca_response =
admin::update_connector(state.clone(), merchant_id, None, &connector_id, request).await?;
match mca_response {
ApplicationResponse::Json(mca_data) => Ok(mca_data),
_ => Err(ApiErrorResponse::InternalServerError.into()),
}
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/files/helpers.rs | crates/router/src/core/files/helpers.rs | use actix_multipart::Field;
use common_utils::errors::CustomResult;
use error_stack::ResultExt;
use futures::TryStreamExt;
use hyperswitch_domain_models::router_response_types::disputes::FileInfo;
use crate::{
core::{
errors::{self, utils::ConnectorErrorExt, StorageErrorExt},
payments, utils,
},
routes::SessionState,
services,
types::{self, api, domain, transformers::ForeignTryFrom},
};
pub async fn read_string(field: &mut Field) -> Option<String> {
let bytes = field.try_next().await;
if let Ok(Some(bytes)) = bytes {
String::from_utf8(bytes.to_vec()).ok()
} else {
None
}
}
pub async fn get_file_purpose(field: &mut Field) -> Option<api::FilePurpose> {
let purpose = read_string(field).await;
match purpose.as_deref() {
Some("dispute_evidence") => Some(api::FilePurpose::DisputeEvidence),
_ => None,
}
}
pub async fn validate_file_upload(
state: &SessionState,
platform: domain::Platform,
create_file_request: api::CreateFileRequest,
) -> CustomResult<(), errors::ApiErrorResponse> {
//File Validation based on the purpose of file upload
match create_file_request.purpose {
api::FilePurpose::DisputeEvidence => {
let dispute_id = &create_file_request
.dispute_id
.ok_or(errors::ApiErrorResponse::MissingDisputeId)?;
let dispute = state
.store
.find_dispute_by_merchant_id_dispute_id(
platform.get_processor().get_account().get_id(),
dispute_id,
)
.await
.to_not_found_response(errors::ApiErrorResponse::DisputeNotFound {
dispute_id: dispute_id.to_string(),
})?;
// Connector is not called for validating the file, connector_id can be passed as None safely
let connector_data = api::ConnectorData::get_connector_by_name(
&state.conf.connectors,
&dispute.connector,
api::GetToken::Connector,
None,
)?;
let validation = connector_data.connector.validate_file_upload(
create_file_request.purpose,
create_file_request.file_size,
create_file_request.file_type.clone(),
);
match validation {
Ok(()) => Ok(()),
Err(err) => match err.current_context() {
errors::ConnectorError::FileValidationFailed { reason } => {
Err(errors::ApiErrorResponse::FileValidationFailed {
reason: reason.to_string(),
}
.into())
}
//We are using parent error and ignoring this
_error => Err(err
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("File validation failed"))?,
},
}
}
}
}
pub async fn delete_file_using_file_id(
state: &SessionState,
file_key: String,
platform: &domain::Platform,
) -> CustomResult<(), errors::ApiErrorResponse> {
let file_metadata_object = state
.store
.find_file_metadata_by_merchant_id_file_id(
platform.get_processor().get_account().get_id(),
&file_key,
)
.await
.change_context(errors::ApiErrorResponse::FileNotFound)?;
let (provider, provider_file_id) = match (
file_metadata_object.file_upload_provider,
file_metadata_object.provider_file_id,
file_metadata_object.available,
) {
(Some(provider), Some(provider_file_id), true) => (provider, provider_file_id),
_ => Err(errors::ApiErrorResponse::FileNotAvailable)
.attach_printable("File not available")?,
};
match provider {
diesel_models::enums::FileUploadProvider::Router => state
.file_storage_client
.delete_file(&provider_file_id)
.await
.change_context(errors::ApiErrorResponse::InternalServerError),
_ => Err(errors::ApiErrorResponse::FileProviderNotSupported {
message: "Not Supported because provider is not Router".to_string(),
}
.into()),
}
}
pub async fn retrieve_file_from_connector(
state: &SessionState,
file_metadata: diesel_models::file::FileMetadata,
dispute_id: Option<String>,
platform: &domain::Platform,
) -> CustomResult<Vec<u8>, errors::ApiErrorResponse> {
let connector = &types::Connector::foreign_try_from(
file_metadata
.file_upload_provider
.ok_or(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Missing file upload provider")?,
)?
.to_string();
let connector_data = api::ConnectorData::get_connector_by_name(
&state.conf.connectors,
connector,
api::GetToken::Connector,
file_metadata.merchant_connector_id.clone(),
)?;
let dispute = match dispute_id {
Some(dispute) => Some(
state
.store
.find_dispute_by_merchant_id_dispute_id(
platform.get_processor().get_account().get_id(),
&dispute,
)
.await
.to_not_found_response(errors::ApiErrorResponse::DisputeNotFound {
dispute_id: dispute,
})?,
),
None => None,
};
let connector_integration: services::BoxedFilesConnectorIntegrationInterface<
api::Retrieve,
types::RetrieveFileRequestData,
types::RetrieveFileResponse,
> = connector_data.connector.get_connector_integration();
let router_data = utils::construct_retrieve_file_router_data(
state,
platform,
&file_metadata,
dispute,
connector,
)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed constructing the retrieve file router data")?;
let response = services::execute_connector_processing_step(
state,
connector_integration,
&router_data,
payments::CallConnectorAction::Trigger,
None,
None,
)
.await
.to_files_failed_response()
.attach_printable("Failed while calling retrieve file connector api")?;
let retrieve_file_response =
response
.response
.map_err(|err| errors::ApiErrorResponse::ExternalConnectorError {
code: err.code,
message: err.message,
connector: connector.to_string(),
status_code: err.status_code,
reason: err.reason,
})?;
Ok(retrieve_file_response.file_data)
}
pub async fn retrieve_file_and_provider_file_id_from_file_id(
state: &SessionState,
file_id: Option<String>,
dispute_id: Option<String>,
platform: &domain::Platform,
is_connector_file_data_required: api::FileDataRequired,
) -> CustomResult<FileInfo, errors::ApiErrorResponse> {
match file_id {
None => Ok(FileInfo {
file_data: None,
provider_file_id: None,
file_type: None,
}),
Some(file_key) => {
let file_metadata_object = state
.store
.find_file_metadata_by_merchant_id_file_id(
platform.get_processor().get_account().get_id(),
&file_key,
)
.await
.change_context(errors::ApiErrorResponse::FileNotFound)?;
let (provider, provider_file_id) = match (
file_metadata_object.file_upload_provider,
file_metadata_object.provider_file_id.clone(),
file_metadata_object.available,
) {
(Some(provider), Some(provider_file_id), true) => (provider, provider_file_id),
_ => Err(errors::ApiErrorResponse::FileNotAvailable)
.attach_printable("File not available")?,
};
match provider {
diesel_models::enums::FileUploadProvider::Router => Ok(FileInfo {
file_data: Some(
state
.file_storage_client
.retrieve_file(&provider_file_id)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)?,
),
provider_file_id: Some(provider_file_id),
file_type: Some(file_metadata_object.file_type),
}),
_ => {
let connector_file_data = match is_connector_file_data_required {
api::FileDataRequired::Required => Some(
retrieve_file_from_connector(
state,
file_metadata_object.clone(),
dispute_id,
platform,
)
.await?,
),
api::FileDataRequired::NotRequired => None,
};
Ok(FileInfo {
file_data: connector_file_data,
provider_file_id: Some(provider_file_id),
file_type: Some(file_metadata_object.file_type),
})
}
}
}
}
}
#[cfg(feature = "v2")]
//Upload file to connector if it supports / store it in S3 and return file_upload_provider, provider_file_id accordingly
pub async fn upload_and_get_provider_provider_file_id_profile_id(
state: &SessionState,
platform: &domain::Platform,
create_file_request: &api::CreateFileRequest,
file_key: String,
) -> CustomResult<
(
String,
api_models::enums::FileUploadProvider,
Option<common_utils::id_type::ProfileId>,
Option<common_utils::id_type::MerchantConnectorAccountId>,
),
errors::ApiErrorResponse,
> {
todo!()
}
#[cfg(feature = "v1")]
//Upload file to connector if it supports / store it in S3 and return file_upload_provider, provider_file_id accordingly
pub async fn upload_and_get_provider_provider_file_id_profile_id(
state: &SessionState,
platform: &domain::Platform,
create_file_request: &api::CreateFileRequest,
file_key: String,
) -> CustomResult<
(
String,
api_models::enums::FileUploadProvider,
Option<common_utils::id_type::ProfileId>,
Option<common_utils::id_type::MerchantConnectorAccountId>,
),
errors::ApiErrorResponse,
> {
match create_file_request.purpose {
api::FilePurpose::DisputeEvidence => {
let dispute_id = create_file_request
.dispute_id
.clone()
.ok_or(errors::ApiErrorResponse::MissingDisputeId)?;
let dispute = state
.store
.find_dispute_by_merchant_id_dispute_id(
platform.get_processor().get_account().get_id(),
&dispute_id,
)
.await
.to_not_found_response(errors::ApiErrorResponse::DisputeNotFound { dispute_id })?;
let connector_data = api::ConnectorData::get_connector_by_name(
&state.conf.connectors,
&dispute.connector,
api::GetToken::Connector,
dispute.merchant_connector_id.clone(),
)?;
if connector_data.connector_name.supports_file_storage_module() {
let payment_intent = state
.store
.find_payment_intent_by_payment_id_merchant_id(
&dispute.payment_id,
platform.get_processor().get_account().get_id(),
platform.get_processor().get_key_store(),
platform.get_processor().get_account().storage_scheme,
)
.await
.change_context(errors::ApiErrorResponse::PaymentNotFound)?;
let payment_attempt = state
.store
.find_payment_attempt_by_attempt_id_merchant_id(
&dispute.attempt_id,
platform.get_processor().get_account().get_id(),
platform.get_processor().get_account().storage_scheme,
platform.get_processor().get_key_store(),
)
.await
.change_context(errors::ApiErrorResponse::PaymentNotFound)?;
let connector_integration: services::BoxedFilesConnectorIntegrationInterface<
api::Upload,
types::UploadFileRequestData,
types::UploadFileResponse,
> = connector_data.connector.get_connector_integration();
let router_data = utils::construct_upload_file_router_data(
state,
&payment_intent,
&payment_attempt,
platform,
create_file_request,
dispute,
&connector_data.connector_name.to_string(),
file_key,
)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed constructing the upload file router data")?;
let response = services::execute_connector_processing_step(
state,
connector_integration,
&router_data,
payments::CallConnectorAction::Trigger,
None,
None,
)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed while calling upload file connector api")?;
let upload_file_response = response.response.map_err(|err| {
errors::ApiErrorResponse::ExternalConnectorError {
code: err.code,
message: err.message,
connector: connector_data.connector_name.to_string(),
status_code: err.status_code,
reason: err.reason,
}
})?;
Ok((
upload_file_response.provider_file_id,
api_models::enums::FileUploadProvider::foreign_try_from(
&connector_data.connector_name,
)?,
payment_intent.profile_id,
payment_attempt.merchant_connector_id,
))
} else {
state
.file_storage_client
.upload_file(&file_key, create_file_request.file.clone())
.await
.change_context(errors::ApiErrorResponse::InternalServerError)?;
Ok((
file_key,
api_models::enums::FileUploadProvider::Router,
None,
None,
))
}
}
}
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/utils/refunds_transformers.rs | crates/router/src/core/utils/refunds_transformers.rs | pub struct SplitRefundInput {
pub refund_request: Option<common_types::refunds::SplitRefund>,
pub payment_charges: Option<common_types::payments::ConnectorChargeResponseData>,
pub split_payment_request: Option<common_types::payments::SplitPaymentsRequest>,
pub charge_id: Option<String>,
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/utils/refunds_validator.rs | crates/router/src/core/utils/refunds_validator.rs | use diesel_models::refund as diesel_refund;
use error_stack::report;
use router_env::{instrument, tracing};
use time::PrimitiveDateTime;
use crate::{
core::errors::{self, CustomResult, RouterResult},
types::{
self,
api::enums as api_enums,
storage::{self, enums},
},
utils::{self, OptionExt},
};
// Limit constraints for refunds list flow
pub const LOWER_LIMIT: i64 = 1;
pub const UPPER_LIMIT: i64 = 100;
pub const DEFAULT_LIMIT: i64 = 10;
#[derive(Debug, thiserror::Error)]
pub enum RefundValidationError {
#[error("The payment attempt was not successful")]
UnsuccessfulPaymentAttempt,
#[error("The refund amount exceeds the amount captured")]
RefundAmountExceedsPaymentAmount,
#[error("The order has expired")]
OrderExpired,
#[error("The maximum refund count for this payment attempt")]
MaxRefundCountReached,
#[error("There is already another refund request for this payment attempt")]
DuplicateRefund,
}
#[instrument(skip_all)]
pub fn validate_success_transaction(
transaction: &storage::PaymentAttempt,
) -> CustomResult<(), RefundValidationError> {
if transaction.status != enums::AttemptStatus::Charged {
Err(report!(RefundValidationError::UnsuccessfulPaymentAttempt))?
}
Ok(())
}
#[instrument(skip_all)]
pub fn validate_refund_amount(
amount_captured: i64,
all_refunds: &[diesel_refund::Refund],
refund_amount: i64,
) -> CustomResult<(), RefundValidationError> {
let total_refunded_amount: i64 = all_refunds
.iter()
.filter_map(|refund| {
if refund.refund_status != enums::RefundStatus::Failure
&& refund.refund_status != enums::RefundStatus::TransactionFailure
{
Some(refund.refund_amount.get_amount_as_i64())
} else {
None
}
})
.sum();
utils::when(
refund_amount > (amount_captured - total_refunded_amount),
|| {
Err(report!(
RefundValidationError::RefundAmountExceedsPaymentAmount
))
},
)
}
#[instrument(skip_all)]
pub fn validate_payment_order_age(
created_at: &PrimitiveDateTime,
refund_max_age: i64,
) -> CustomResult<(), RefundValidationError> {
let current_time = common_utils::date_time::now();
utils::when(
(current_time - *created_at).whole_days() > refund_max_age,
|| Err(report!(RefundValidationError::OrderExpired)),
)
}
#[instrument(skip_all)]
pub fn validate_maximum_refund_against_payment_attempt(
all_refunds: &[diesel_refund::Refund],
refund_max_attempts: usize,
) -> CustomResult<(), RefundValidationError> {
utils::when(all_refunds.len() > refund_max_attempts, || {
Err(report!(RefundValidationError::MaxRefundCountReached))
})
}
pub fn validate_refund_list(limit: Option<i64>) -> CustomResult<i64, errors::ApiErrorResponse> {
match limit {
Some(limit_val) => {
if !(LOWER_LIMIT..=UPPER_LIMIT).contains(&limit_val) {
Err(errors::ApiErrorResponse::InvalidRequestData {
message: "limit should be in between 1 and 100".to_string(),
}
.into())
} else {
Ok(limit_val)
}
}
None => Ok(DEFAULT_LIMIT),
}
}
#[cfg(feature = "v1")]
pub fn validate_for_valid_refunds(
payment_attempt: &hyperswitch_domain_models::payments::payment_attempt::PaymentAttempt,
connector: api_models::enums::Connector,
) -> RouterResult<()> {
let payment_method = payment_attempt
.payment_method
.as_ref()
.get_required_value("payment_method")?;
match payment_method {
diesel_models::enums::PaymentMethod::PayLater
| diesel_models::enums::PaymentMethod::Wallet => {
let payment_method_type = payment_attempt
.payment_method_type
.get_required_value("payment_method_type")?;
utils::when(
matches!(
(connector, payment_method_type),
(
api_models::enums::Connector::Braintree,
diesel_models::enums::PaymentMethodType::Paypal,
)
),
|| {
Err(errors::ApiErrorResponse::RefundNotPossible {
connector: connector.to_string(),
}
.into())
},
)
}
_ => Ok(()),
}
}
#[cfg(feature = "v2")]
pub fn validate_for_valid_refunds(
payment_attempt: &hyperswitch_domain_models::payments::payment_attempt::PaymentAttempt,
connector: api_models::enums::Connector,
) -> RouterResult<()> {
let payment_method_type = payment_attempt.payment_method_type;
match payment_method_type {
diesel_models::enums::PaymentMethod::PayLater
| diesel_models::enums::PaymentMethod::Wallet => {
let payment_method_subtype = payment_attempt.payment_method_subtype;
utils::when(
matches!(
(connector, payment_method_subtype),
(
api_models::enums::Connector::Braintree,
diesel_models::enums::PaymentMethodType::Paypal,
)
),
|| {
Err(errors::ApiErrorResponse::RefundNotPossible {
connector: connector.to_string(),
}
.into())
},
)
}
_ => Ok(()),
}
}
pub fn validate_stripe_charge_refund(
charge_type_option: Option<api_enums::PaymentChargeType>,
split_refund_request: &Option<common_types::refunds::SplitRefund>,
) -> RouterResult<types::ChargeRefundsOptions> {
let charge_type = charge_type_option.ok_or_else(|| {
report!(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Missing `charge_type` in PaymentAttempt.")
})?;
let refund_request = match split_refund_request {
Some(common_types::refunds::SplitRefund::StripeSplitRefund(stripe_split_refund)) => {
stripe_split_refund
}
_ => Err(errors::ApiErrorResponse::MissingRequiredField {
field_name: "stripe_split_refund",
})?,
};
let options = match charge_type {
api_enums::PaymentChargeType::Stripe(api_enums::StripeChargeType::Direct) => {
types::ChargeRefundsOptions::Direct(types::DirectChargeRefund {
revert_platform_fee: refund_request
.revert_platform_fee
.get_required_value("revert_platform_fee")?,
})
}
api_enums::PaymentChargeType::Stripe(api_enums::StripeChargeType::Destination) => {
types::ChargeRefundsOptions::Destination(types::DestinationChargeRefund {
revert_platform_fee: refund_request
.revert_platform_fee
.get_required_value("revert_platform_fee")?,
revert_transfer: refund_request
.revert_transfer
.get_required_value("revert_transfer")?,
})
}
};
Ok(options)
}
pub fn validate_adyen_charge_refund(
adyen_split_payment_response: &common_types::domain::AdyenSplitData,
adyen_split_refund_request: &common_types::domain::AdyenSplitData,
) -> RouterResult<()> {
if adyen_split_refund_request.store != adyen_split_payment_response.store {
return Err(report!(errors::ApiErrorResponse::InvalidDataValue {
field_name: "split_payments.adyen_split_payment.store",
}));
};
for refund_split_item in adyen_split_refund_request.split_items.iter() {
let refund_split_reference = refund_split_item.reference.clone();
let matching_payment_split_item = adyen_split_payment_response
.split_items
.iter()
.find(|payment_split_item| refund_split_reference == payment_split_item.reference);
if let Some(payment_split_item) = matching_payment_split_item {
if let Some((refund_amount, payment_amount)) =
refund_split_item.amount.zip(payment_split_item.amount)
{
if refund_amount > payment_amount {
return Err(report!(errors::ApiErrorResponse::InvalidRequestData {
message: format!(
"Invalid refund amount for split item, reference: {refund_split_reference}",
),
}));
}
}
if let Some((refund_account, payment_account)) = refund_split_item
.account
.as_ref()
.zip(payment_split_item.account.as_ref())
{
if !refund_account.eq(payment_account) {
return Err(report!(errors::ApiErrorResponse::InvalidRequestData {
message: format!(
"Invalid refund account for split item, reference: {refund_split_reference}",
),
}));
}
}
if refund_split_item.split_type != payment_split_item.split_type {
return Err(report!(errors::ApiErrorResponse::InvalidRequestData {
message: format!(
"Invalid refund split_type for split item, reference: {refund_split_reference}",
),
}));
}
} else {
return Err(report!(errors::ApiErrorResponse::InvalidRequestData {
message: format!(
"No matching payment split item found for reference: {refund_split_reference}",
),
}));
}
}
Ok(())
}
pub fn validate_xendit_charge_refund(
xendit_split_payment_response: &common_types::payments::XenditChargeResponseData,
xendit_split_refund_request: &common_types::domain::XenditSplitSubMerchantData,
) -> RouterResult<Option<String>> {
match xendit_split_payment_response {
common_types::payments::XenditChargeResponseData::MultipleSplits(
payment_sub_merchant_data,
) => {
if payment_sub_merchant_data.for_user_id
!= Some(xendit_split_refund_request.for_user_id.clone())
{
return Err(errors::ApiErrorResponse::InvalidDataValue {
field_name: "xendit_split_refund.for_user_id does not match xendit_split_payment.for_user_id",
}.into());
}
Ok(Some(xendit_split_refund_request.for_user_id.clone()))
}
common_types::payments::XenditChargeResponseData::SingleSplit(
payment_sub_merchant_data,
) => {
if payment_sub_merchant_data.for_user_id != xendit_split_refund_request.for_user_id {
return Err(errors::ApiErrorResponse::InvalidDataValue {
field_name: "xendit_split_refund.for_user_id does not match xendit_split_payment.for_user_id",
}.into());
}
Ok(Some(xendit_split_refund_request.for_user_id.clone()))
}
}
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/webhooks/recovery_incoming.rs | crates/router/src/core/webhooks/recovery_incoming.rs | use std::{collections::HashMap, marker::PhantomData, str::FromStr};
use api_models::{enums as api_enums, payments as api_payments, webhooks};
use common_utils::{
ext_traits::{AsyncExt, ValueExt},
id_type,
};
use diesel_models::process_tracker as storage;
use error_stack::{report, ResultExt};
use futures::stream::SelectNextSome;
use hyperswitch_domain_models::{
payments as domain_payments,
revenue_recovery::{self, RecoveryPaymentIntent},
router_data_v2::flow_common_types,
router_flow_types,
router_request_types::revenue_recovery as revenue_recovery_request,
router_response_types::revenue_recovery as revenue_recovery_response,
types as router_types,
};
use hyperswitch_interfaces::webhooks as interface_webhooks;
use masking::{PeekInterface, Secret};
use router_env::{instrument, logger, tracing};
use services::kafka;
use storage::business_status;
use crate::{
consts,
core::{
self, admin,
errors::{self, CustomResult},
payments::{self, helpers},
},
db::{errors::RevenueRecoveryError, StorageInterface},
routes::{app::ReqState, metrics, SessionState},
services::{
self,
connector_integration_interface::{self, RouterDataConversion},
},
types::{
self, api, domain,
storage::{
revenue_recovery as storage_revenue_recovery,
revenue_recovery_redis_operation::{
PaymentProcessorTokenDetails, PaymentProcessorTokenStatus, RedisTokenManager,
},
},
transformers::ForeignFrom,
},
workflows::revenue_recovery as revenue_recovery_flow,
};
#[cfg(feature = "v2")]
pub const REVENUE_RECOVERY: &str = "revenue_recovery";
#[allow(clippy::too_many_arguments)]
#[instrument(skip_all)]
#[cfg(feature = "revenue_recovery")]
pub async fn recovery_incoming_webhook_flow(
state: SessionState,
platform: domain::Platform,
business_profile: domain::Profile,
source_verified: bool,
connector_enum: &connector_integration_interface::ConnectorEnum,
billing_connector_account: hyperswitch_domain_models::merchant_connector_account::MerchantConnectorAccount,
connector_name: &str,
request_details: &hyperswitch_interfaces::webhooks::IncomingWebhookRequestDetails<'_>,
event_type: webhooks::IncomingWebhookEvent,
req_state: ReqState,
object_ref_id: &webhooks::ObjectReferenceId,
) -> CustomResult<webhooks::WebhookResponseTracker, errors::RevenueRecoveryError> {
// Source verification is necessary for revenue recovery webhooks flow since We don't have payment intent/attempt object created before in our system.
common_utils::fp_utils::when(!source_verified, || {
Err(report!(
errors::RevenueRecoveryError::WebhookAuthenticationFailed
))
})?;
let connector = api_enums::Connector::from_str(connector_name)
.change_context(errors::RevenueRecoveryError::InvoiceWebhookProcessingFailed)
.attach_printable_lazy(|| format!("unable to parse connector name {connector_name:?}"))?;
let billing_connectors_with_invoice_sync_call = &state.conf.billing_connectors_invoice_sync;
let should_billing_connector_invoice_api_called = billing_connectors_with_invoice_sync_call
.billing_connectors_which_requires_invoice_sync_call
.contains(&connector);
let billing_connectors_with_payment_sync_call = &state.conf.billing_connectors_payment_sync;
let should_billing_connector_payment_api_called = billing_connectors_with_payment_sync_call
.billing_connectors_which_require_payment_sync
.contains(&connector);
let billing_connector_payment_details =
BillingConnectorPaymentsSyncResponseData::get_billing_connector_payment_details(
should_billing_connector_payment_api_called,
&state,
&platform,
&billing_connector_account,
connector_name,
object_ref_id,
)
.await?;
let invoice_id = billing_connector_payment_details
.clone()
.map(|data| data.merchant_reference_id);
let billing_connector_invoice_details =
BillingConnectorInvoiceSyncResponseData::get_billing_connector_invoice_details(
should_billing_connector_invoice_api_called,
&state,
&platform,
&billing_connector_account,
connector_name,
invoice_id,
)
.await?;
// Checks whether we have data in billing_connector_invoice_details , if it is there then we construct revenue recovery invoice from it else it takes from webhook
let invoice_details = RevenueRecoveryInvoice::get_recovery_invoice_details(
connector_enum,
request_details,
billing_connector_invoice_details.as_ref(),
)?;
// Fetch the intent using merchant reference id, if not found create new intent.
let payment_intent = invoice_details
.get_payment_intent(&state, &req_state, &platform, &business_profile)
.await
.transpose()
.async_unwrap_or_else(|| async {
invoice_details
.create_payment_intent(&state, &req_state, &platform, &business_profile)
.await
})
.await?;
let is_event_recovery_transaction_event = event_type.is_recovery_transaction_event();
let (recovery_attempt_from_payment_attempt, recovery_intent_from_payment_attempt) =
RevenueRecoveryAttempt::get_recovery_payment_attempt(
is_event_recovery_transaction_event,
&billing_connector_account,
&state,
connector_enum,
&req_state,
billing_connector_payment_details.as_ref(),
request_details,
&platform,
&business_profile,
&payment_intent,
&invoice_details.0,
)
.await?;
// Publish event to Kafka
if let Some(ref attempt) = recovery_attempt_from_payment_attempt {
// Passing `platform` here
let recovery_payment_tuple =
&RecoveryPaymentTuple::new(&recovery_intent_from_payment_attempt, attempt);
if let Err(e) = RecoveryPaymentTuple::publish_revenue_recovery_event_to_kafka(
&state,
recovery_payment_tuple,
None,
)
.await
{
logger::error!(
"Failed to publish revenue recovery event to kafka : {:?}",
e
);
};
}
let attempt_triggered_by = recovery_attempt_from_payment_attempt
.as_ref()
.and_then(|attempt| attempt.get_attempt_triggered_by());
let recovery_action = RecoveryAction {
action: RecoveryAction::get_action(event_type, attempt_triggered_by),
};
let mca_retry_threshold = billing_connector_account
.get_retry_threshold()
.ok_or(report!(
errors::RevenueRecoveryError::BillingThresholdRetryCountFetchFailed
))?;
let intent_retry_count = recovery_intent_from_payment_attempt
.feature_metadata
.as_ref()
.and_then(|metadata| metadata.get_retry_count())
.ok_or(report!(errors::RevenueRecoveryError::RetryCountFetchFailed))?;
logger::info!("Intent retry count: {:?}", intent_retry_count);
recovery_action
.handle_action(
&state,
&business_profile,
&platform,
&billing_connector_account,
mca_retry_threshold,
intent_retry_count,
&(
recovery_attempt_from_payment_attempt,
recovery_intent_from_payment_attempt,
),
)
.await
}
async fn handle_monitoring_threshold(
state: &SessionState,
business_profile: &domain::Profile,
key_store: &domain::MerchantKeyStore,
) -> CustomResult<webhooks::WebhookResponseTracker, errors::RevenueRecoveryError> {
let db = &*state.store;
let key_manager_state = &(state).into();
let monitoring_threshold_config = state.conf.revenue_recovery.monitoring_threshold_in_seconds;
let retry_algorithm_type = state.conf.revenue_recovery.retry_algorithm_type;
let revenue_recovery_retry_algorithm = business_profile
.revenue_recovery_retry_algorithm_data
.clone()
.ok_or(report!(
errors::RevenueRecoveryError::RetryAlgorithmTypeNotFound
))?;
if revenue_recovery_retry_algorithm
.has_exceeded_monitoring_threshold(monitoring_threshold_config)
{
let profile_wrapper = admin::ProfileWrapper::new(business_profile.clone());
profile_wrapper
.update_revenue_recovery_algorithm_under_profile(
db,
key_manager_state,
key_store,
retry_algorithm_type,
)
.await
.change_context(errors::RevenueRecoveryError::RetryAlgorithmUpdationFailed)?;
}
Ok(webhooks::WebhookResponseTracker::NoEffect)
}
#[allow(clippy::too_many_arguments)]
async fn handle_schedule_failed_payment(
billing_connector_account: &domain::MerchantConnectorAccount,
intent_retry_count: u16,
mca_retry_threshold: u16,
state: &SessionState,
platform: &domain::Platform,
payment_attempt_with_recovery_intent: &(
Option<revenue_recovery::RecoveryPaymentAttempt>,
revenue_recovery::RecoveryPaymentIntent,
),
business_profile: &domain::Profile,
revenue_recovery_retry: api_enums::RevenueRecoveryAlgorithmType,
) -> CustomResult<webhooks::WebhookResponseTracker, errors::RevenueRecoveryError> {
let (recovery_attempt_from_payment_attempt, recovery_intent_from_payment_attempt) =
payment_attempt_with_recovery_intent;
// When intent_retry_count is less than or equal to threshold
(intent_retry_count <= mca_retry_threshold)
.then(|| {
logger::error!(
"Payment retry count {} is less than threshold {}",
intent_retry_count,
mca_retry_threshold
);
Ok(webhooks::WebhookResponseTracker::NoEffect)
})
.async_unwrap_or_else(|| async {
// Call calculate_job
core::revenue_recovery::upsert_calculate_pcr_task(
billing_connector_account,
state,
platform,
recovery_intent_from_payment_attempt,
business_profile,
intent_retry_count,
recovery_attempt_from_payment_attempt
.as_ref()
.map(|attempt| attempt.attempt_id.clone()),
storage::ProcessTrackerRunner::PassiveRecoveryWorkflow,
revenue_recovery_retry,
)
.await
})
.await
}
#[derive(Debug)]
pub struct RevenueRecoveryInvoice(revenue_recovery::RevenueRecoveryInvoiceData);
#[derive(Debug)]
pub struct RevenueRecoveryAttempt(revenue_recovery::RevenueRecoveryAttemptData);
impl RevenueRecoveryInvoice {
pub async fn get_or_create_custom_recovery_intent(
data: api_models::payments::RecoveryPaymentsCreate,
state: &SessionState,
req_state: &ReqState,
platform: &domain::Platform,
profile: &domain::Profile,
) -> CustomResult<revenue_recovery::RecoveryPaymentIntent, errors::RevenueRecoveryError> {
let recovery_intent = Self(revenue_recovery::RevenueRecoveryInvoiceData::foreign_from(
data,
));
recovery_intent
.get_payment_intent(state, req_state, platform, profile)
.await
.transpose()
.async_unwrap_or_else(|| async {
recovery_intent
.create_payment_intent(state, req_state, platform, profile)
.await
})
.await
}
fn get_recovery_invoice_details(
connector_enum: &connector_integration_interface::ConnectorEnum,
request_details: &hyperswitch_interfaces::webhooks::IncomingWebhookRequestDetails<'_>,
billing_connector_invoice_details: Option<
&revenue_recovery_response::BillingConnectorInvoiceSyncResponse,
>,
) -> CustomResult<Self, errors::RevenueRecoveryError> {
billing_connector_invoice_details.map_or_else(
|| {
interface_webhooks::IncomingWebhook::get_revenue_recovery_invoice_details(
connector_enum,
request_details,
)
.change_context(errors::RevenueRecoveryError::InvoiceWebhookProcessingFailed)
.attach_printable("Failed while getting revenue recovery invoice details")
.map(RevenueRecoveryInvoice)
},
|data| {
Ok(Self(revenue_recovery::RevenueRecoveryInvoiceData::from(
data,
)))
},
)
}
async fn get_payment_intent(
&self,
state: &SessionState,
req_state: &ReqState,
platform: &domain::Platform,
profile: &domain::Profile,
) -> CustomResult<Option<revenue_recovery::RecoveryPaymentIntent>, errors::RevenueRecoveryError>
{
let payment_response = Box::pin(payments::payments_get_intent_using_merchant_reference(
state.clone(),
platform.clone(),
profile.clone(),
req_state.clone(),
&self.0.merchant_reference_id,
hyperswitch_domain_models::payments::HeaderPayload::default(),
))
.await;
let response = match payment_response {
Ok(services::ApplicationResponse::JsonWithHeaders((payments_response, _))) => {
let payment_id = payments_response.id.clone();
let status = payments_response.status;
let feature_metadata = payments_response.feature_metadata;
let merchant_id = platform.get_processor().get_account().get_id().clone();
let revenue_recovery_invoice_data = &self.0;
Ok(Some(revenue_recovery::RecoveryPaymentIntent {
payment_id,
status,
feature_metadata,
merchant_id,
merchant_reference_id: Some(
revenue_recovery_invoice_data.merchant_reference_id.clone(),
),
invoice_amount: revenue_recovery_invoice_data.amount,
invoice_currency: revenue_recovery_invoice_data.currency,
created_at: revenue_recovery_invoice_data.billing_started_at,
billing_address: revenue_recovery_invoice_data.billing_address.clone(),
}))
}
Err(err)
if matches!(
err.current_context(),
&errors::ApiErrorResponse::PaymentNotFound
) =>
{
Ok(None)
}
Ok(_) => Err(errors::RevenueRecoveryError::PaymentIntentFetchFailed)
.attach_printable("Unexpected response from payment intent core"),
error @ Err(_) => {
logger::error!(?error);
Err(errors::RevenueRecoveryError::PaymentIntentFetchFailed)
.attach_printable("failed to fetch payment intent recovery webhook flow")
}
}?;
Ok(response)
}
async fn create_payment_intent(
&self,
state: &SessionState,
req_state: &ReqState,
platform: &domain::Platform,
profile: &domain::Profile,
) -> CustomResult<revenue_recovery::RecoveryPaymentIntent, errors::RevenueRecoveryError> {
let payload = api_payments::PaymentsCreateIntentRequest::from(&self.0);
let global_payment_id = id_type::GlobalPaymentId::generate(&state.conf.cell_information.id);
let create_intent_response = Box::pin(payments::payments_intent_core::<
router_flow_types::payments::PaymentCreateIntent,
api_payments::PaymentsIntentResponse,
_,
_,
hyperswitch_domain_models::payments::PaymentIntentData<
router_flow_types::payments::PaymentCreateIntent,
>,
>(
state.clone(),
req_state.clone(),
platform.clone(),
profile.clone(),
payments::operations::PaymentIntentCreate,
payload,
global_payment_id,
hyperswitch_domain_models::payments::HeaderPayload::default(),
))
.await
.change_context(errors::RevenueRecoveryError::PaymentIntentCreateFailed)?;
let response = create_intent_response
.get_json_body()
.change_context(errors::RevenueRecoveryError::PaymentIntentCreateFailed)
.attach_printable("expected json response")?;
let merchant_id = platform.get_processor().get_account().get_id().clone();
let revenue_recovery_invoice_data = &self.0;
Ok(revenue_recovery::RecoveryPaymentIntent {
payment_id: response.id,
status: response.status,
feature_metadata: response.feature_metadata,
merchant_id,
merchant_reference_id: Some(
revenue_recovery_invoice_data.merchant_reference_id.clone(),
),
invoice_amount: revenue_recovery_invoice_data.amount,
invoice_currency: revenue_recovery_invoice_data.currency,
created_at: revenue_recovery_invoice_data.billing_started_at,
billing_address: revenue_recovery_invoice_data.billing_address.clone(),
})
}
}
impl RevenueRecoveryAttempt {
pub async fn load_recovery_attempt_from_api(
data: api_models::payments::RecoveryPaymentsCreate,
state: &SessionState,
req_state: &ReqState,
platform: &domain::Platform,
profile: &domain::Profile,
payment_intent: revenue_recovery::RecoveryPaymentIntent,
payment_merchant_connector_account: domain::MerchantConnectorAccount,
) -> CustomResult<
(
revenue_recovery::RecoveryPaymentAttempt,
revenue_recovery::RecoveryPaymentIntent,
),
errors::RevenueRecoveryError,
> {
let recovery_attempt = Self(revenue_recovery::RevenueRecoveryAttemptData::foreign_from(
&data,
));
recovery_attempt
.get_payment_attempt(state, req_state, platform, profile, &payment_intent)
.await
.transpose()
.async_unwrap_or_else(|| async {
recovery_attempt
.record_payment_attempt(
state,
req_state,
platform,
profile,
&payment_intent,
&data.billing_merchant_connector_id,
Some(payment_merchant_connector_account),
)
.await
})
.await
}
fn get_recovery_invoice_transaction_details(
connector_enum: &connector_integration_interface::ConnectorEnum,
request_details: &hyperswitch_interfaces::webhooks::IncomingWebhookRequestDetails<'_>,
billing_connector_payment_details: Option<
&revenue_recovery_response::BillingConnectorPaymentsSyncResponse,
>,
billing_connector_invoice_details: &revenue_recovery::RevenueRecoveryInvoiceData,
) -> CustomResult<Self, errors::RevenueRecoveryError> {
billing_connector_payment_details.map_or_else(
|| {
interface_webhooks::IncomingWebhook::get_revenue_recovery_attempt_details(
connector_enum,
request_details,
)
.change_context(errors::RevenueRecoveryError::TransactionWebhookProcessingFailed)
.attach_printable(
"Failed to get recovery attempt details from the billing connector",
)
.map(RevenueRecoveryAttempt)
},
|data| {
Ok(Self(revenue_recovery::RevenueRecoveryAttemptData::from((
data,
billing_connector_invoice_details,
))))
},
)
}
pub fn get_revenue_recovery_attempt(
payment_intent: &domain_payments::PaymentIntent,
revenue_recovery_metadata: &api_payments::PaymentRevenueRecoveryMetadata,
billing_connector_account: &domain::MerchantConnectorAccount,
card_info: api_payments::AdditionalCardInfo,
payment_processor_token: &str,
) -> CustomResult<Self, errors::RevenueRecoveryError> {
let revenue_recovery_data = payment_intent
.create_revenue_recovery_attempt_data(
revenue_recovery_metadata.clone(),
billing_connector_account,
card_info,
payment_processor_token,
)
.change_context(errors::RevenueRecoveryError::RevenueRecoveryAttemptDataCreateFailed)
.attach_printable("Failed to build recovery attempt data")?;
Ok(Self(revenue_recovery_data))
}
async fn get_payment_attempt(
&self,
state: &SessionState,
req_state: &ReqState,
platform: &domain::Platform,
profile: &domain::Profile,
payment_intent: &revenue_recovery::RecoveryPaymentIntent,
) -> CustomResult<
Option<(
revenue_recovery::RecoveryPaymentAttempt,
revenue_recovery::RecoveryPaymentIntent,
)>,
errors::RevenueRecoveryError,
> {
let attempt_response =
Box::pin(payments::payments_list_attempts_using_payment_intent_id::<
payments::operations::PaymentGetListAttempts,
api_payments::PaymentAttemptListResponse,
_,
payments::operations::payment_attempt_list::PaymentGetListAttempts,
hyperswitch_domain_models::payments::PaymentAttemptListData<
payments::operations::PaymentGetListAttempts,
>,
>(
state.clone(),
req_state.clone(),
platform.clone(),
profile.clone(),
payments::operations::PaymentGetListAttempts,
api_payments::PaymentAttemptListRequest {
payment_intent_id: payment_intent.payment_id.clone(),
},
payment_intent.payment_id.clone(),
hyperswitch_domain_models::payments::HeaderPayload::default(),
))
.await;
let response = match attempt_response {
Ok(services::ApplicationResponse::JsonWithHeaders((payments_response, _))) => {
let final_attempt = self
.0
.charge_id
.as_ref()
.map(|charge_id| {
payments_response
.find_attempt_in_attempts_list_using_charge_id(charge_id.clone())
})
.unwrap_or_else(|| {
self.0
.connector_transaction_id
.as_ref()
.and_then(|transaction_id| {
payments_response
.find_attempt_in_attempts_list_using_connector_transaction_id(
transaction_id,
)
})
});
let payment_attempt =
final_attempt.map(|res| revenue_recovery::RecoveryPaymentAttempt {
attempt_id: res.id.to_owned(),
attempt_status: res.status.to_owned(),
feature_metadata: res.feature_metadata.to_owned(),
amount: res.amount.net_amount,
network_advice_code: res.error.clone().and_then(|e| e.network_advice_code), // Placeholder, to be populated if available
network_decline_code: res
.error
.clone()
.and_then(|e| e.network_decline_code), // Placeholder, to be populated if available
error_code: res.error.clone().map(|error| error.code),
created_at: res.created_at,
});
// If we have an attempt, combine it with payment_intent in a tuple.
let res_with_payment_intent_and_attempt =
payment_attempt.map(|attempt| (attempt, (*payment_intent).clone()));
Ok(res_with_payment_intent_and_attempt)
}
Ok(_) => Err(errors::RevenueRecoveryError::PaymentAttemptFetchFailed)
.attach_printable("Unexpected response from payment intent core"),
error @ Err(_) => {
logger::error!(?error);
Err(errors::RevenueRecoveryError::PaymentAttemptFetchFailed)
.attach_printable("failed to fetch payment attempt in recovery webhook flow")
}
}?;
Ok(response)
}
#[allow(clippy::too_many_arguments)]
async fn record_payment_attempt(
&self,
state: &SessionState,
req_state: &ReqState,
platform: &domain::Platform,
profile: &domain::Profile,
payment_intent: &revenue_recovery::RecoveryPaymentIntent,
billing_connector_account_id: &id_type::MerchantConnectorAccountId,
payment_connector_account: Option<domain::MerchantConnectorAccount>,
) -> CustomResult<
(
revenue_recovery::RecoveryPaymentAttempt,
revenue_recovery::RecoveryPaymentIntent,
),
errors::RevenueRecoveryError,
> {
let payment_connector_id = payment_connector_account.as_ref().map(|account: &hyperswitch_domain_models::merchant_connector_account::MerchantConnectorAccount| account.id.clone());
let payment_connector_name = payment_connector_account
.as_ref()
.map(|account| account.connector_name);
let request_payload: api_payments::PaymentsAttemptRecordRequest = self
.create_payment_record_request(
state,
billing_connector_account_id,
payment_connector_id,
payment_connector_name,
common_enums::TriggeredBy::External,
)
.await?;
let attempt_response = Box::pin(payments::record_attempt_core(
state.clone(),
req_state.clone(),
platform.clone(),
profile.clone(),
request_payload,
payment_intent.payment_id.clone(),
hyperswitch_domain_models::payments::HeaderPayload::default(),
))
.await;
let (recovery_attempt, updated_recovery_intent) = match attempt_response {
Ok(services::ApplicationResponse::JsonWithHeaders((attempt_response, _))) => {
Ok((
revenue_recovery::RecoveryPaymentAttempt {
attempt_id: attempt_response.id.clone(),
attempt_status: attempt_response.status,
feature_metadata: attempt_response.payment_attempt_feature_metadata,
amount: attempt_response.amount,
network_advice_code: attempt_response
.error_details
.clone()
.and_then(|error| error.network_decline_code), // Placeholder, to be populated if available
network_decline_code: attempt_response
.error_details
.clone()
.and_then(|error| error.network_decline_code), // Placeholder, to be populated if available
error_code: attempt_response
.error_details
.clone()
.map(|error| error.code),
created_at: attempt_response.created_at,
},
revenue_recovery::RecoveryPaymentIntent {
payment_id: payment_intent.payment_id.clone(),
status: attempt_response.status.into(), // Using status from attempt_response
feature_metadata: attempt_response.payment_intent_feature_metadata, // Using feature_metadata from attempt_response
merchant_id: payment_intent.merchant_id.clone(),
merchant_reference_id: payment_intent.merchant_reference_id.clone(),
invoice_amount: payment_intent.invoice_amount,
invoice_currency: payment_intent.invoice_currency,
created_at: payment_intent.created_at,
billing_address: payment_intent.billing_address.clone(),
},
))
}
Ok(_) => Err(errors::RevenueRecoveryError::PaymentAttemptFetchFailed)
.attach_printable("Unexpected response from record attempt core"),
error @ Err(_) => {
logger::error!(?error);
Err(errors::RevenueRecoveryError::PaymentAttemptFetchFailed)
.attach_printable("failed to record attempt in recovery webhook flow")
}
}?;
let response = (recovery_attempt, updated_recovery_intent);
self.store_payment_processor_tokens_in_redis(state, &response.0, payment_connector_name)
.await
.map_err(|e| {
router_env::logger::error!(
"Failed to store payment processor tokens in Redis: {:?}",
e
);
errors::RevenueRecoveryError::RevenueRecoveryRedisInsertFailed
})?;
Ok(response)
}
pub async fn create_payment_record_request(
&self,
state: &SessionState,
billing_merchant_connector_account_id: &id_type::MerchantConnectorAccountId,
payment_merchant_connector_account_id: Option<id_type::MerchantConnectorAccountId>,
payment_connector: Option<common_enums::connector_enums::Connector>,
triggered_by: common_enums::TriggeredBy,
) -> CustomResult<api_payments::PaymentsAttemptRecordRequest, errors::RevenueRecoveryError>
{
let revenue_recovery_attempt_data = &self.0;
let amount_details =
api_payments::PaymentAttemptAmountDetails::from(revenue_recovery_attempt_data);
let feature_metadata = api_payments::PaymentAttemptFeatureMetadata {
revenue_recovery: Some(api_payments::PaymentAttemptRevenueRecoveryData {
// Since we are recording the external paymenmt attempt, this is hardcoded to External
attempt_triggered_by: triggered_by,
charge_id: self.0.charge_id.clone(),
}),
};
let card_info = revenue_recovery_attempt_data
.card_info
.card_isin
.clone()
.async_and_then(|isin| async move {
let issuer_identifier_number = isin.clone();
state
.store
.get_card_info(issuer_identifier_number.as_str())
.await
.map_err(|error| services::logger::warn!(card_info_error=?error))
.ok()
})
.await
.flatten();
let payment_method_data = api_models::payments::RecordAttemptPaymentMethodDataRequest {
payment_method_data: api_models::payments::AdditionalPaymentData::Card(Box::new(
revenue_recovery_attempt_data.card_info.clone(),
)),
billing: None,
};
let card_issuer = revenue_recovery_attempt_data.card_info.card_issuer.clone();
let error =
Option::<api_payments::RecordAttemptErrorDetails>::from(revenue_recovery_attempt_data);
Ok(api_payments::PaymentsAttemptRecordRequest {
amount_details,
status: revenue_recovery_attempt_data.status,
billing: None,
shipping: None,
connector: payment_connector,
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | true |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/webhooks/outgoing_v2.rs | crates/router/src/core/webhooks/outgoing_v2.rs | use std::collections::HashMap;
use api_models::{webhook_events, webhooks};
use common_utils::{ext_traits, request, type_name, types::keymanager};
use diesel_models::process_tracker::business_status;
use error_stack::{report, Report, ResultExt};
use hyperswitch_domain_models::type_encryption::{crypto_operation, CryptoOperation};
use hyperswitch_interfaces::consts;
use router_env::{
instrument,
tracing::{self, Instrument},
};
use super::{
types,
utils::{self, increment_webhook_outgoing_received_count},
MERCHANT_ID,
};
use crate::{
core::{
errors::{self, CustomResult},
metrics,
},
events::outgoing_webhook_logs,
logger,
routes::{app::SessionStateInfo, SessionState},
services,
types::{
api, domain,
storage::{self, enums},
transformers::ForeignFrom,
},
};
#[allow(clippy::too_many_arguments)]
#[instrument(skip_all)]
pub(crate) async fn create_event_and_trigger_outgoing_webhook(
state: SessionState,
business_profile: domain::Profile,
merchant_key_store: &domain::MerchantKeyStore,
event_type: enums::EventType,
event_class: enums::EventClass,
primary_object_id: String,
primary_object_type: enums::EventObjectType,
content: api::OutgoingWebhookContent,
primary_object_created_at: time::PrimitiveDateTime,
) -> CustomResult<(), errors::ApiErrorResponse> {
let delivery_attempt = enums::WebhookDeliveryAttempt::InitialAttempt;
let idempotent_event_id =
utils::get_idempotent_event_id(&primary_object_id, event_type, delivery_attempt)
.change_context(errors::ApiErrorResponse::WebhookProcessingFailure)
.attach_printable("Failed to generate idempotent event ID")?;
let webhook_url_result = business_profile
.get_webhook_url_from_profile()
.change_context(errors::WebhooksFlowError::MerchantWebhookUrlNotConfigured);
if utils::is_outgoing_webhook_disabled(
&state,
&webhook_url_result,
&business_profile,
&idempotent_event_id,
) {
return Ok(());
}
let event_id = utils::generate_event_id();
let merchant_id = business_profile.merchant_id.clone();
let now = common_utils::date_time::now();
let outgoing_webhook = api::OutgoingWebhook {
merchant_id: merchant_id.clone(),
event_id: event_id.clone(),
event_type,
content: content.clone(),
timestamp: now,
};
let request_content = get_outgoing_webhook_request(outgoing_webhook, &business_profile)
.change_context(errors::ApiErrorResponse::WebhookProcessingFailure)
.attach_printable("Failed to construct outgoing webhook request content")?;
let event_metadata = storage::EventMetadata::foreign_from(&content);
let key_manager_state = &(&state).into();
let new_event = domain::Event {
event_id: event_id.clone(),
event_type,
event_class,
is_webhook_notified: false,
primary_object_id,
primary_object_type,
created_at: now,
merchant_id: Some(business_profile.merchant_id.clone()),
business_profile_id: Some(business_profile.get_id().to_owned()),
primary_object_created_at: Some(primary_object_created_at),
idempotent_event_id: Some(idempotent_event_id.clone()),
initial_attempt_id: Some(event_id.clone()),
request: Some(
crypto_operation(
key_manager_state,
type_name!(domain::Event),
CryptoOperation::Encrypt(
ext_traits::Encode::encode_to_string_of_json(&request_content)
.change_context(errors::ApiErrorResponse::WebhookProcessingFailure)
.attach_printable("Failed to encode outgoing webhook request content")
.map(masking::Secret::new)?,
),
keymanager::Identifier::Merchant(merchant_key_store.merchant_id.clone()),
masking::PeekInterface::peek(merchant_key_store.key.get_inner()),
)
.await
.and_then(|val| val.try_into_operation())
.change_context(errors::ApiErrorResponse::WebhookProcessingFailure)
.attach_printable("Failed to encrypt outgoing webhook request content")?,
),
response: None,
delivery_attempt: Some(delivery_attempt),
metadata: Some(event_metadata),
is_overall_delivery_successful: Some(false),
};
let event_insert_result = state
.store
.insert_event(new_event, merchant_key_store)
.await;
let event = match event_insert_result {
Ok(event) => Ok(event),
Err(error) => {
if error.current_context().is_db_unique_violation() {
// If the event_id already exists in the database, it indicates that the event for the resource has already been sent, so we skip the flow
logger::debug!("Event with idempotent ID `{idempotent_event_id}` already exists in the database");
return Ok(());
} else {
logger::error!(event_insertion_failure=?error);
Err(error
.change_context(errors::ApiErrorResponse::WebhookProcessingFailure)
.attach_printable("Failed to insert event in events table"))
}
}
}?;
let cloned_key_store = merchant_key_store.clone();
// Using a tokio spawn here and not arbiter because not all caller of this function
// may have an actix arbiter
tokio::spawn(
async move {
Box::pin(trigger_webhook_and_raise_event(
state,
business_profile,
&cloned_key_store,
event,
request_content,
delivery_attempt,
Some(content),
))
.await;
}
.in_current_span(),
);
Ok(())
}
#[allow(clippy::too_many_arguments)]
#[instrument(skip_all)]
pub(crate) async fn trigger_webhook_and_raise_event(
state: SessionState,
business_profile: domain::Profile,
merchant_key_store: &domain::MerchantKeyStore,
event: domain::Event,
request_content: webhook_events::OutgoingWebhookRequestContent,
delivery_attempt: enums::WebhookDeliveryAttempt,
content: Option<api::OutgoingWebhookContent>,
) {
logger::debug!(
event_id=%event.event_id,
idempotent_event_id=?event.idempotent_event_id,
initial_attempt_id=?event.initial_attempt_id,
"Attempting to send webhook"
);
let merchant_id = business_profile.merchant_id.clone();
let trigger_webhook_result = trigger_webhook_to_merchant(
state.clone(),
business_profile,
merchant_key_store,
event.clone(),
request_content,
delivery_attempt,
)
.await;
let _ =
raise_webhooks_analytics_event(state, trigger_webhook_result, content, merchant_id, event)
.await;
}
async fn trigger_webhook_to_merchant(
state: SessionState,
business_profile: domain::Profile,
merchant_key_store: &domain::MerchantKeyStore,
event: domain::Event,
request_content: webhook_events::OutgoingWebhookRequestContent,
delivery_attempt: enums::WebhookDeliveryAttempt,
) -> CustomResult<
(domain::Event, Option<Report<errors::WebhooksFlowError>>),
errors::WebhooksFlowError,
> {
let webhook_url = business_profile
.get_webhook_url_from_profile()
.change_context(errors::WebhooksFlowError::MerchantWebhookUrlNotConfigured)?;
let response = build_and_send_request(&state, request_content, webhook_url).await;
metrics::WEBHOOK_OUTGOING_COUNT.add(
1,
router_env::metric_attributes!((MERCHANT_ID, business_profile.merchant_id.clone())),
);
logger::debug!(outgoing_webhook_response=?response);
match response {
Ok(response) => {
delivery_attempt
.handle_success_response(
state,
merchant_key_store.clone(),
&business_profile.merchant_id,
&event.event_id,
None,
response,
)
.await
}
Err(client_error) => {
delivery_attempt
.handle_error_response(
state,
merchant_key_store.clone(),
&business_profile.merchant_id,
&event.event_id,
client_error,
)
.await
}
}
}
async fn raise_webhooks_analytics_event(
state: SessionState,
trigger_webhook_result: CustomResult<
(domain::Event, Option<Report<errors::WebhooksFlowError>>),
errors::WebhooksFlowError,
>,
content: Option<api::OutgoingWebhookContent>,
merchant_id: common_utils::id_type::MerchantId,
fallback_event: domain::Event,
) {
let (updated_event, optional_error) = match trigger_webhook_result {
Ok((updated_event, error)) => (updated_event, error),
Err(error) => (fallback_event, Some(error)),
};
let error = optional_error.and_then(|error| {
logger::error!(?error, "Failed to send webhook to merchant");
serde_json::to_value(error.current_context())
.change_context(errors::ApiErrorResponse::WebhookProcessingFailure)
.inspect_err(|error| {
logger::error!(?error, "Failed to serialize outgoing webhook error as JSON");
})
.ok()
});
let outgoing_webhook_event_content = content
.as_ref()
.and_then(
outgoing_webhook_logs::OutgoingWebhookEventMetric::get_outgoing_webhook_event_content,
)
.or_else(|| {
updated_event
.metadata
.map(outgoing_webhook_logs::OutgoingWebhookEventContent::foreign_from)
});
// Get status_code from webhook response
let status_code = {
let webhook_response: Option<webhook_events::OutgoingWebhookResponseContent> =
updated_event.response.and_then(|res| {
ext_traits::StringExt::parse_struct(
masking::PeekInterface::peek(res.get_inner()),
"OutgoingWebhookResponseContent",
)
.map_err(|error| {
logger::error!(?error, "Error deserializing webhook response");
error
})
.ok()
});
webhook_response.and_then(|res| res.status_code)
};
let webhook_event = outgoing_webhook_logs::OutgoingWebhookEvent::new(
state.tenant.tenant_id.clone(),
merchant_id,
updated_event.event_id,
updated_event.event_type,
outgoing_webhook_event_content,
error,
updated_event.initial_attempt_id,
status_code,
updated_event.delivery_attempt,
);
state.event_handler().log_event(&webhook_event);
}
pub(crate) fn get_outgoing_webhook_request(
outgoing_webhook: api::OutgoingWebhook,
business_profile: &domain::Profile,
) -> CustomResult<webhook_events::OutgoingWebhookRequestContent, errors::WebhooksFlowError> {
#[inline]
fn get_outgoing_webhook_request_inner<WebhookType: types::OutgoingWebhookType>(
outgoing_webhook: api::OutgoingWebhook,
business_profile: &domain::Profile,
) -> CustomResult<webhook_events::OutgoingWebhookRequestContent, errors::WebhooksFlowError>
{
let mut headers = vec![
(
reqwest::header::CONTENT_TYPE.to_string(),
mime::APPLICATION_JSON.essence_str().into(),
),
(
reqwest::header::USER_AGENT.to_string(),
consts::USER_AGENT.to_string().into(),
),
];
let transformed_outgoing_webhook = WebhookType::from(outgoing_webhook);
let payment_response_hash_key = business_profile.payment_response_hash_key.clone();
let custom_headers = business_profile
.outgoing_webhook_custom_http_headers
.clone()
.map(|headers| {
ext_traits::ValueExt::parse_value::<HashMap<String, String>>(
masking::ExposeInterface::expose(headers.into_inner()),
"HashMap<String,String>",
)
.change_context(errors::WebhooksFlowError::OutgoingWebhookEncodingFailed)
.attach_printable("Failed to deserialize outgoing webhook custom HTTP headers")
})
.transpose()?;
if let Some(ref map) = custom_headers {
headers.extend(
map.iter()
.map(|(key, value)| (key.clone(), masking::Mask::into_masked(value.clone()))),
);
};
let outgoing_webhooks_signature = transformed_outgoing_webhook
.get_outgoing_webhooks_signature(payment_response_hash_key)?;
if let Some(signature) = outgoing_webhooks_signature.signature {
WebhookType::add_webhook_header(&mut headers, signature)
}
Ok(webhook_events::OutgoingWebhookRequestContent {
body: outgoing_webhooks_signature.payload,
headers: headers
.into_iter()
.map(|(name, value)| (name, masking::Secret::new(value.into_inner())))
.collect(),
})
}
get_outgoing_webhook_request_inner::<webhooks::OutgoingWebhook>(
outgoing_webhook,
business_profile,
)
}
async fn build_and_send_request(
state: &SessionState,
request_content: webhook_events::OutgoingWebhookRequestContent,
webhook_url: String,
) -> Result<reqwest::Response, Report<common_enums::ApiClientError>> {
let headers = request_content
.headers
.into_iter()
.map(|(name, value)| (name, masking::Mask::into_masked(value)))
.collect();
let request = services::RequestBuilder::new()
.method(services::Method::Post)
.url(&webhook_url)
.attach_default_headers()
.headers(headers)
.set_body(request::RequestContent::RawBytes(
masking::ExposeInterface::expose(request_content.body).into_bytes(),
))
.build();
state
.api_client
.send_request(state, request, None, false)
.await
}
async fn api_client_error_handler(
state: SessionState,
merchant_key_store: domain::MerchantKeyStore,
merchant_id: &common_utils::id_type::MerchantId,
event_id: &str,
client_error: Report<errors::ApiClientError>,
delivery_attempt: enums::WebhookDeliveryAttempt,
_schedule_webhook_retry: types::ScheduleWebhookRetry,
) -> CustomResult<
(domain::Event, Option<Report<errors::WebhooksFlowError>>),
errors::WebhooksFlowError,
> {
// Not including detailed error message in response information since it contains too
// much of diagnostic information to be exposed to the merchant.
let is_webhook_notified = false;
let response_to_store = webhook_events::OutgoingWebhookResponseContent {
body: None,
headers: None,
status_code: None,
error_message: Some("Unable to send request to merchant server".to_string()),
};
let updated_event = update_event_in_storage(
state,
is_webhook_notified,
response_to_store,
merchant_key_store,
merchant_id,
event_id,
)
.await?;
let error = client_error.change_context(errors::WebhooksFlowError::CallToMerchantFailed);
logger::error!(
?error,
?delivery_attempt,
"An error occurred when sending webhook to merchant"
);
//TODO: add outgoing webhook retries support
// if let ScheduleWebhookRetry::WithProcessTracker(process_tracker) = schedule_webhook_retry {
// // Schedule a retry attempt for webhook delivery
// outgoing_webhook_retry::retry_webhook_delivery_task(
// &*state.store,
// merchant_id,
// *process_tracker,
// )
// .await
// .change_context(errors::WebhooksFlowError::OutgoingWebhookRetrySchedulingFailed)?;
// }
Ok((updated_event, Some(error)))
}
async fn update_event_in_storage(
state: SessionState,
is_webhook_notified: bool,
outgoing_webhook_response: webhook_events::OutgoingWebhookResponseContent,
merchant_key_store: domain::MerchantKeyStore,
merchant_id: &common_utils::id_type::MerchantId,
event_id: &str,
) -> CustomResult<domain::Event, errors::WebhooksFlowError> {
let key_manager_state = &(&state).into();
let event_update = domain::EventUpdate::UpdateResponse {
is_webhook_notified,
response: Some(
crypto_operation(
key_manager_state,
type_name!(domain::Event),
CryptoOperation::Encrypt(
ext_traits::Encode::encode_to_string_of_json(&outgoing_webhook_response)
.change_context(
errors::WebhooksFlowError::OutgoingWebhookResponseEncodingFailed,
)
.map(masking::Secret::new)?,
),
keymanager::Identifier::Merchant(merchant_key_store.merchant_id.clone()),
masking::PeekInterface::peek(merchant_key_store.key.get_inner()),
)
.await
.and_then(|val| val.try_into_operation())
.change_context(errors::WebhooksFlowError::WebhookEventUpdationFailed)
.attach_printable("Failed to encrypt outgoing webhook response content")?,
),
};
state
.store
.update_event_by_merchant_id_event_id(
merchant_id,
event_id,
event_update,
&merchant_key_store,
)
.await
.change_context(errors::WebhooksFlowError::WebhookEventUpdationFailed)
}
async fn update_overall_delivery_status_in_storage(
state: SessionState,
merchant_key_store: domain::MerchantKeyStore,
merchant_id: &common_utils::id_type::MerchantId,
updated_event: &domain::Event,
) -> CustomResult<(), errors::WebhooksFlowError> {
let update_overall_delivery_status = domain::EventUpdate::OverallDeliveryStatusUpdate {
is_overall_delivery_successful: true,
};
let initial_attempt_id = updated_event.initial_attempt_id.as_ref();
let delivery_attempt = updated_event.delivery_attempt;
if let Some((
initial_attempt_id,
enums::WebhookDeliveryAttempt::InitialAttempt
| enums::WebhookDeliveryAttempt::AutomaticRetry,
)) = initial_attempt_id.zip(delivery_attempt)
{
state
.store
.update_event_by_merchant_id_event_id(
merchant_id,
initial_attempt_id.as_str(),
update_overall_delivery_status,
&merchant_key_store,
)
.await
.change_context(errors::WebhooksFlowError::WebhookEventUpdationFailed)
.attach_printable("Failed to update initial delivery attempt")?;
}
Ok(())
}
async fn handle_successful_delivery(
state: SessionState,
merchant_key_store: domain::MerchantKeyStore,
updated_event: &domain::Event,
merchant_id: &common_utils::id_type::MerchantId,
process_tracker: Option<storage::ProcessTracker>,
business_status: &'static str,
) -> CustomResult<(), errors::WebhooksFlowError> {
update_overall_delivery_status_in_storage(
state.clone(),
merchant_key_store.clone(),
merchant_id,
updated_event,
)
.await?;
increment_webhook_outgoing_received_count(merchant_id);
match process_tracker {
Some(process_tracker) => state
.store
.as_scheduler()
.finish_process_with_business_status(process_tracker, business_status)
.await
.change_context(
errors::WebhooksFlowError::OutgoingWebhookProcessTrackerTaskUpdateFailed,
),
None => Ok(()),
}
}
async fn handle_failed_delivery(
_state: SessionState,
merchant_id: &common_utils::id_type::MerchantId,
delivery_attempt: enums::WebhookDeliveryAttempt,
status_code: u16,
log_message: &'static str,
_schedule_webhook_retry: types::ScheduleWebhookRetry,
) -> CustomResult<(), errors::WebhooksFlowError> {
utils::increment_webhook_outgoing_not_received_count(merchant_id);
let error = report!(errors::WebhooksFlowError::NotReceivedByMerchant);
logger::warn!(?error, ?delivery_attempt, status_code, %log_message);
//TODO: add outgoing webhook retries support
// if let ScheduleWebhookRetry::WithProcessTracker(process_tracker) = schedule_webhook_retry {
// // Schedule a retry attempt for webhook delivery
// outgoing_webhook_retry::retry_webhook_delivery_task(
// &*state.store,
// merchant_id,
// *process_tracker,
// )
// .await
// .change_context(errors::WebhooksFlowError::OutgoingWebhookRetrySchedulingFailed)?;
// }
Err(error)
}
impl ForeignFrom<&api::OutgoingWebhookContent> for storage::EventMetadata {
fn foreign_from(content: &api::OutgoingWebhookContent) -> Self {
match content {
webhooks::OutgoingWebhookContent::PaymentDetails(payments_response) => Self::Payment {
payment_id: payments_response.id.clone(),
},
webhooks::OutgoingWebhookContent::RefundDetails(refund_response) => Self::Refund {
payment_id: refund_response.payment_id.clone(),
refund_id: refund_response.id.clone(),
},
webhooks::OutgoingWebhookContent::DisputeDetails(dispute_response) => {
//TODO: add support for dispute outgoing webhook
todo!()
}
webhooks::OutgoingWebhookContent::MandateDetails(mandate_response) => Self::Mandate {
payment_method_id: mandate_response.payment_method_id.clone(),
mandate_id: mandate_response.mandate_id.clone(),
},
#[cfg(feature = "payouts")]
webhooks::OutgoingWebhookContent::PayoutDetails(payout_response) => Self::Payout {
payout_id: payout_response.payout_id.clone(),
},
}
}
}
impl ForeignFrom<storage::EventMetadata> for outgoing_webhook_logs::OutgoingWebhookEventContent {
fn foreign_from(event_metadata: storage::EventMetadata) -> Self {
match event_metadata {
diesel_models::EventMetadata::Payment { payment_id } => Self::Payment {
payment_id,
content: serde_json::Value::Null,
},
diesel_models::EventMetadata::Payout { payout_id } => Self::Payout {
payout_id,
content: serde_json::Value::Null,
},
diesel_models::EventMetadata::Refund {
payment_id,
refund_id,
} => Self::Refund {
payment_id,
refund_id,
content: serde_json::Value::Null,
},
diesel_models::EventMetadata::Dispute {
payment_id,
attempt_id,
dispute_id,
} => Self::Dispute {
payment_id,
attempt_id,
dispute_id,
content: serde_json::Value::Null,
},
diesel_models::EventMetadata::Mandate {
payment_method_id,
mandate_id,
} => Self::Mandate {
payment_method_id,
mandate_id,
content: serde_json::Value::Null,
},
diesel_models::EventMetadata::Subscription {
subscription_id,
invoice_id,
payment_id,
} => Self::Subscription {
subscription_id,
invoice_id,
payment_id,
content: serde_json::Value::Null,
},
}
}
}
trait OutgoingWebhookResponseHandler {
async fn handle_error_response(
&self,
state: SessionState,
merchant_key_store: domain::MerchantKeyStore,
merchant_id: &common_utils::id_type::MerchantId,
event_id: &str,
client_error: Report<errors::ApiClientError>,
) -> CustomResult<
(domain::Event, Option<Report<errors::WebhooksFlowError>>),
errors::WebhooksFlowError,
>;
async fn handle_success_response(
&self,
state: SessionState,
merchant_key_store: domain::MerchantKeyStore,
merchant_id: &common_utils::id_type::MerchantId,
event_id: &str,
process_tracker: Option<storage::ProcessTracker>,
response: reqwest::Response,
) -> CustomResult<
(domain::Event, Option<Report<errors::WebhooksFlowError>>),
errors::WebhooksFlowError,
>;
}
impl OutgoingWebhookResponseHandler for enums::WebhookDeliveryAttempt {
async fn handle_error_response(
&self,
state: SessionState,
merchant_key_store: domain::MerchantKeyStore,
merchant_id: &common_utils::id_type::MerchantId,
event_id: &str,
client_error: Report<errors::ApiClientError>,
) -> CustomResult<
(domain::Event, Option<Report<errors::WebhooksFlowError>>),
errors::WebhooksFlowError,
> {
let schedule_webhook_retry = match self {
Self::InitialAttempt | Self::ManualRetry => types::ScheduleWebhookRetry::NoSchedule,
Self::AutomaticRetry => {
// ScheduleWebhookRetry::WithProcessTracker(Box::new(process_tracker))
todo!()
}
};
api_client_error_handler(
state,
merchant_key_store,
merchant_id,
event_id,
client_error,
*self,
schedule_webhook_retry,
)
.await
}
async fn handle_success_response(
&self,
state: SessionState,
merchant_key_store: domain::MerchantKeyStore,
merchant_id: &common_utils::id_type::MerchantId,
event_id: &str,
process_tracker: Option<storage::ProcessTracker>,
response: reqwest::Response,
) -> CustomResult<
(domain::Event, Option<Report<errors::WebhooksFlowError>>),
errors::WebhooksFlowError,
> {
let status_code = response.status();
let is_webhook_notified = status_code.is_success();
let response_struct = types::WebhookResponse { response };
let outgoing_webhook_response = response_struct
.get_outgoing_webhook_response_content()
.await;
let updated_event = update_event_in_storage(
state.clone(),
is_webhook_notified,
outgoing_webhook_response,
merchant_key_store.clone(),
merchant_id,
event_id,
)
.await?;
let webhook_action_handler = get_action_handler(*self);
let result = if is_webhook_notified {
webhook_action_handler
.notified_action(
state,
merchant_key_store,
&updated_event,
merchant_id,
process_tracker,
)
.await
} else {
webhook_action_handler
.not_notified_action(state, merchant_id, status_code.as_u16())
.await
};
Ok((updated_event, result))
}
}
#[async_trait::async_trait]
trait WebhookNotificationHandler: Send + Sync {
async fn notified_action(
&self,
state: SessionState,
merchant_key_store: domain::MerchantKeyStore,
updated_event: &domain::Event,
merchant_id: &common_utils::id_type::MerchantId,
process_tracker: Option<storage::ProcessTracker>,
) -> Option<Report<errors::WebhooksFlowError>>;
async fn not_notified_action(
&self,
state: SessionState,
merchant_id: &common_utils::id_type::MerchantId,
status_code: u16,
) -> Option<Report<errors::WebhooksFlowError>>;
}
struct InitialAttempt;
struct AutomaticRetry;
struct ManualRetry;
#[async_trait::async_trait]
impl WebhookNotificationHandler for InitialAttempt {
async fn notified_action(
&self,
state: SessionState,
merchant_key_store: domain::MerchantKeyStore,
updated_event: &domain::Event,
merchant_id: &common_utils::id_type::MerchantId,
process_tracker: Option<storage::ProcessTracker>,
) -> Option<Report<errors::WebhooksFlowError>> {
handle_successful_delivery(
state,
merchant_key_store,
updated_event,
merchant_id,
process_tracker,
business_status::INITIAL_DELIVERY_ATTEMPT_SUCCESSFUL,
)
.await
.err()
.map(|error: Report<errors::WebhooksFlowError>| report!(error))
}
async fn not_notified_action(
&self,
state: SessionState,
merchant_id: &common_utils::id_type::MerchantId,
status_code: u16,
) -> Option<Report<errors::WebhooksFlowError>> {
handle_failed_delivery(
state.clone(),
merchant_id,
enums::WebhookDeliveryAttempt::InitialAttempt,
status_code,
"Ignoring error when sending webhook to merchant",
types::ScheduleWebhookRetry::NoSchedule,
)
.await
.err()
.map(|error| report!(error))
}
}
#[async_trait::async_trait]
impl WebhookNotificationHandler for AutomaticRetry {
async fn notified_action(
&self,
_state: SessionState,
_merchant_key_store: domain::MerchantKeyStore,
_updated_event: &domain::Event,
_merchant_id: &common_utils::id_type::MerchantId,
_process_tracker: Option<storage::ProcessTracker>,
) -> Option<Report<errors::WebhooksFlowError>> {
todo!()
}
async fn not_notified_action(
&self,
_state: SessionState,
_merchant_id: &common_utils::id_type::MerchantId,
_status_code: u16,
) -> Option<Report<errors::WebhooksFlowError>> {
todo!()
}
}
#[async_trait::async_trait]
impl WebhookNotificationHandler for ManualRetry {
async fn notified_action(
&self,
_state: SessionState,
_merchant_key_store: domain::MerchantKeyStore,
_updated_event: &domain::Event,
merchant_id: &common_utils::id_type::MerchantId,
_process_tracker: Option<storage::ProcessTracker>,
) -> Option<Report<errors::WebhooksFlowError>> {
increment_webhook_outgoing_received_count(merchant_id);
None
}
async fn not_notified_action(
&self,
state: SessionState,
merchant_id: &common_utils::id_type::MerchantId,
status_code: u16,
) -> Option<Report<errors::WebhooksFlowError>> {
handle_failed_delivery(
state.clone(),
merchant_id,
enums::WebhookDeliveryAttempt::ManualRetry,
status_code,
"Ignoring error when sending webhook to merchant",
types::ScheduleWebhookRetry::NoSchedule,
)
.await
.err()
.map(|error| report!(error))
}
}
fn get_action_handler(
attempt: enums::WebhookDeliveryAttempt,
) -> Box<dyn WebhookNotificationHandler> {
match attempt {
enums::WebhookDeliveryAttempt::InitialAttempt => Box::new(InitialAttempt),
enums::WebhookDeliveryAttempt::AutomaticRetry => Box::new(AutomaticRetry),
enums::WebhookDeliveryAttempt::ManualRetry => Box::new(ManualRetry),
}
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/webhooks/webhook_events.rs | crates/router/src/core/webhooks/webhook_events.rs | use std::collections::HashSet;
use common_utils::{self, errors::CustomResult, fp_utils};
use error_stack::ResultExt;
use masking::PeekInterface;
use router_env::{instrument, tracing};
use crate::{
core::errors::{self, RouterResponse, StorageErrorExt},
routes::SessionState,
services::ApplicationResponse,
types::{api, domain, storage, transformers::ForeignTryFrom},
utils::{OptionExt, StringExt},
};
const INITIAL_DELIVERY_ATTEMPTS_LIST_MAX_LIMIT: i64 = 100;
const INITIAL_DELIVERY_ATTEMPTS_LIST_MAX_DAYS: i64 = 90;
#[derive(Debug)]
enum MerchantAccountOrProfile {
MerchantAccount(Box<domain::MerchantAccount>),
Profile(Box<domain::Profile>),
}
#[instrument(skip(state))]
pub async fn list_initial_delivery_attempts(
state: SessionState,
merchant_id: common_utils::id_type::MerchantId,
api_constraints: api::webhook_events::EventListConstraints,
) -> RouterResponse<api::webhook_events::TotalEventsResponse> {
let profile_id = api_constraints.profile_id.clone();
let constraints = api::webhook_events::EventListConstraintsInternal::foreign_try_from(
api_constraints.clone(),
)?;
let store = state.store.as_ref();
let (account, key_store) =
get_account_and_key_store(state.clone(), merchant_id.clone(), profile_id.clone()).await?;
let now = common_utils::date_time::now();
let events_list_begin_time =
(now.date() - time::Duration::days(INITIAL_DELIVERY_ATTEMPTS_LIST_MAX_DAYS)).midnight();
let (events, total_count) = match constraints {
api_models::webhook_events::EventListConstraintsInternal::ObjectIdFilter { object_id } => {
let events = match account {
MerchantAccountOrProfile::MerchantAccount(merchant_account) => {
store
.list_initial_events_by_merchant_id_primary_object_id(
merchant_account.get_id(),
object_id.as_str(),
&key_store,
)
.await
}
MerchantAccountOrProfile::Profile(business_profile) => {
store
.list_initial_events_by_profile_id_primary_object_id(
business_profile.get_id(),
object_id.as_str(),
&key_store,
)
.await
}
}
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed to list events with specified constraints")?;
let total_count = i64::try_from(events.len())
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Error while converting from usize to i64")?;
(events, total_count)
}
api_models::webhook_events::EventListConstraintsInternal::EventIdFilter { event_id } => {
let event_opt = match account {
MerchantAccountOrProfile::MerchantAccount(merchant_account) => {
store
.find_initial_event_by_merchant_id_initial_attempt_id(
merchant_account.get_id(),
event_id.as_str(),
&key_store,
)
.await
}
MerchantAccountOrProfile::Profile(business_profile) => {
store
.find_initial_event_by_profile_id_initial_attempt_id(
business_profile.get_id(),
event_id.as_str(),
&key_store,
)
.await
}
}
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed to find event with specified event_id")?;
let (events, total_count) = event_opt.map_or((vec![], 0), |event| (vec![event], 1));
(events, total_count)
}
api_models::webhook_events::EventListConstraintsInternal::GenericFilter {
created_after,
created_before,
limit,
offset,
event_classes,
event_types,
is_delivered,
} => {
let limit = match limit {
Some(limit) if limit <= INITIAL_DELIVERY_ATTEMPTS_LIST_MAX_LIMIT => Ok(Some(limit)),
Some(limit) if limit > INITIAL_DELIVERY_ATTEMPTS_LIST_MAX_LIMIT => Err(
errors::ApiErrorResponse::InvalidRequestData{
message: format!("`limit` must be a number less than {INITIAL_DELIVERY_ATTEMPTS_LIST_MAX_LIMIT}")
}
),
_ => Ok(Some(INITIAL_DELIVERY_ATTEMPTS_LIST_MAX_LIMIT)),
}?;
let offset = match offset {
Some(offset) if offset > 0 => Some(offset),
_ => None,
};
let event_classes = event_classes.unwrap_or(HashSet::new());
let mut event_types = event_types.unwrap_or(HashSet::new());
if !event_classes.is_empty() {
event_types = finalize_event_types(event_classes, event_types).await?;
}
fp_utils::when(
!created_after
.zip(created_before)
.map(|(created_after, created_before)| created_after <= created_before)
.unwrap_or(true),
|| {
Err(errors::ApiErrorResponse::InvalidRequestData { message: "The `created_after` timestamp must be an earlier timestamp compared to the `created_before` timestamp".to_string() })
},
)?;
let created_after = match created_after {
Some(created_after) => {
if created_after < events_list_begin_time {
Err(errors::ApiErrorResponse::InvalidRequestData { message: format!("`created_after` must be a timestamp within the past {INITIAL_DELIVERY_ATTEMPTS_LIST_MAX_DAYS} days.") })
} else {
Ok(created_after)
}
}
None => Ok(events_list_begin_time),
}?;
let created_before = match created_before {
Some(created_before) => {
if created_before < events_list_begin_time {
Err(errors::ApiErrorResponse::InvalidRequestData { message: format!("`created_before` must be a timestamp within the past {INITIAL_DELIVERY_ATTEMPTS_LIST_MAX_DAYS} days.") })
} else {
Ok(created_before)
}
}
None => Ok(now),
}?;
let events = match account {
MerchantAccountOrProfile::MerchantAccount(merchant_account) => {
store
.list_initial_events_by_merchant_id_constraints(
merchant_account.get_id(),
created_after,
created_before,
limit,
offset,
event_types.clone(),
is_delivered,
&key_store,
)
.await
}
MerchantAccountOrProfile::Profile(business_profile) => {
store
.list_initial_events_by_profile_id_constraints(
business_profile.get_id(),
created_after,
created_before,
limit,
offset,
event_types.clone(),
is_delivered,
&key_store,
)
.await
}
}
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed to list events with specified constraints")?;
let total_count = store
.count_initial_events_by_constraints(
&merchant_id,
profile_id,
created_after,
created_before,
event_types,
is_delivered,
)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed to get total events count")?;
(events, total_count)
}
};
let events = events
.into_iter()
.map(api::webhook_events::EventListItemResponse::try_from)
.collect::<Result<Vec<_>, _>>()?;
Ok(ApplicationResponse::Json(
api::webhook_events::TotalEventsResponse::new(total_count, events),
))
}
#[instrument(skip(state))]
pub async fn list_delivery_attempts(
state: SessionState,
merchant_id: common_utils::id_type::MerchantId,
initial_attempt_id: String,
) -> RouterResponse<Vec<api::webhook_events::EventRetrieveResponse>> {
let store = state.store.as_ref();
let key_store = store
.get_merchant_key_store_by_merchant_id(
&merchant_id,
&store.get_master_key().to_vec().into(),
)
.await
.to_not_found_response(errors::ApiErrorResponse::MerchantAccountNotFound)?;
let events = store
.list_events_by_merchant_id_initial_attempt_id(
&merchant_id,
&initial_attempt_id,
&key_store,
)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed to list delivery attempts for initial event")?;
if events.is_empty() {
Err(error_stack::report!(
errors::ApiErrorResponse::EventNotFound
))
.attach_printable("No delivery attempts found with the specified `initial_attempt_id`")
} else {
Ok(ApplicationResponse::Json(
events
.into_iter()
.map(api::webhook_events::EventRetrieveResponse::try_from)
.collect::<Result<Vec<_>, _>>()?,
))
}
}
#[instrument(skip(state))]
#[cfg(feature = "v1")]
pub async fn retry_delivery_attempt(
state: SessionState,
merchant_id: common_utils::id_type::MerchantId,
event_id: String,
) -> RouterResponse<api::webhook_events::EventRetrieveResponse> {
let store = state.store.as_ref();
let key_store = store
.get_merchant_key_store_by_merchant_id(
&merchant_id,
&store.get_master_key().to_vec().into(),
)
.await
.to_not_found_response(errors::ApiErrorResponse::MerchantAccountNotFound)?;
let event_to_retry = store
.find_event_by_merchant_id_event_id(&key_store.merchant_id, &event_id, &key_store)
.await
.to_not_found_response(errors::ApiErrorResponse::EventNotFound)?;
let business_profile_id = event_to_retry
.business_profile_id
.get_required_value("business_profile_id")
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed to read business profile ID from event to retry")?;
let business_profile = store
.find_business_profile_by_profile_id(&key_store, &business_profile_id)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed to find business profile")?;
let delivery_attempt = storage::enums::WebhookDeliveryAttempt::ManualRetry;
let new_event_id = super::utils::generate_event_id();
let idempotent_event_id = super::utils::get_idempotent_event_id(
&event_to_retry.primary_object_id,
event_to_retry.event_type,
delivery_attempt,
)
.change_context(errors::ApiErrorResponse::WebhookProcessingFailure)
.attach_printable("Failed to generate idempotent event ID")?;
let now = common_utils::date_time::now();
let new_event = domain::Event {
event_id: new_event_id.clone(),
event_type: event_to_retry.event_type,
event_class: event_to_retry.event_class,
is_webhook_notified: false,
primary_object_id: event_to_retry.primary_object_id,
primary_object_type: event_to_retry.primary_object_type,
created_at: now,
merchant_id: Some(business_profile.merchant_id.clone()),
business_profile_id: Some(business_profile.get_id().to_owned()),
primary_object_created_at: event_to_retry.primary_object_created_at,
idempotent_event_id: Some(idempotent_event_id),
initial_attempt_id: event_to_retry.initial_attempt_id,
request: event_to_retry.request,
response: None,
delivery_attempt: Some(delivery_attempt),
metadata: event_to_retry.metadata,
is_overall_delivery_successful: Some(false),
};
let event = store
.insert_event(new_event, &key_store)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed to insert event")?;
// We only allow retrying deliveries for events with `request` populated.
let request_content = event
.request
.as_ref()
.get_required_value("request")
.change_context(errors::ApiErrorResponse::InternalServerError)?
.peek()
.parse_struct("OutgoingWebhookRequestContent")
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed to parse webhook event request information")?;
Box::pin(super::outgoing::trigger_webhook_and_raise_event(
state.clone(),
business_profile,
&key_store,
event,
request_content,
delivery_attempt,
None,
None,
))
.await;
let updated_event = store
.find_event_by_merchant_id_event_id(&key_store.merchant_id, &new_event_id, &key_store)
.await
.to_not_found_response(errors::ApiErrorResponse::EventNotFound)?;
Ok(ApplicationResponse::Json(
api::webhook_events::EventRetrieveResponse::try_from(updated_event)?,
))
}
async fn get_account_and_key_store(
state: SessionState,
merchant_id: common_utils::id_type::MerchantId,
profile_id: Option<common_utils::id_type::ProfileId>,
) -> errors::RouterResult<(MerchantAccountOrProfile, domain::MerchantKeyStore)> {
let store = state.store.as_ref();
let merchant_key_store = store
.get_merchant_key_store_by_merchant_id(
&merchant_id,
&store.get_master_key().to_vec().into(),
)
.await
.to_not_found_response(errors::ApiErrorResponse::MerchantAccountNotFound)?;
match profile_id {
// If profile ID is specified, return business profile, since a business profile is more
// specific than a merchant account.
Some(profile_id) => {
let business_profile = store
.find_business_profile_by_merchant_id_profile_id(
&merchant_key_store,
&merchant_id,
&profile_id,
)
.await
.attach_printable_lazy(|| {
format!(
"Failed to find business profile by merchant_id `{merchant_id:?}` and profile_id `{profile_id:?}`. \
The merchant_id associated with the business profile `{profile_id:?}` may be \
different than the merchant_id specified (`{merchant_id:?}`)."
)
})
.to_not_found_response(errors::ApiErrorResponse::ProfileNotFound {
id: profile_id.get_string_repr().to_owned(),
})?;
Ok((
MerchantAccountOrProfile::Profile(Box::new(business_profile)),
merchant_key_store,
))
}
None => {
let merchant_account = store
.find_merchant_account_by_merchant_id(&merchant_id, &merchant_key_store)
.await
.to_not_found_response(errors::ApiErrorResponse::MerchantAccountNotFound)?;
Ok((
MerchantAccountOrProfile::MerchantAccount(Box::new(merchant_account)),
merchant_key_store,
))
}
}
}
async fn finalize_event_types(
event_classes: HashSet<common_enums::EventClass>,
mut event_types: HashSet<common_enums::EventType>,
) -> CustomResult<HashSet<common_enums::EventType>, errors::ApiErrorResponse> {
// Examples:
// 1. event_classes = ["payments", "refunds"], event_types = ["payment_succeeded"]
// 2. event_classes = ["refunds"], event_types = ["payment_succeeded"]
// Create possible_event_types based on event_classes
// Example 1: possible_event_types = ["payment_*", "refund_*"]
// Example 2: possible_event_types = ["refund_*"]
let possible_event_types = event_classes
.clone()
.into_iter()
.flat_map(common_enums::EventClass::event_types)
.collect::<HashSet<_>>();
if event_types.is_empty() {
return Ok(possible_event_types);
}
// Extend event_types if disjoint with event_classes
// Example 1: event_types = ["payment_succeeded", "refund_*"], is_disjoint is used to extend "refund_*" and ignore "payment_*".
// Example 2: event_types = ["payment_succeeded", "refund_*"], is_disjoint is only used to extend "refund_*".
event_classes.into_iter().for_each(|class| {
let valid_event_types = class.event_types();
if event_types.is_disjoint(&valid_event_types) {
event_types.extend(valid_event_types);
}
});
// Validate event_types is a subset of possible_event_types
// Example 1: event_types is a subset of possible_event_types (valid)
// Example 2: event_types is not a subset of possible_event_types (error due to "payment_succeeded")
if !event_types.is_subset(&possible_event_types) {
return Err(error_stack::report!(
errors::ApiErrorResponse::InvalidRequestData {
message: "`event_types` must be a subset of `event_classes`".to_string(),
}
));
}
Ok(event_types.clone())
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/webhooks/network_tokenization_incoming.rs | crates/router/src/core/webhooks/network_tokenization_incoming.rs | use std::str::FromStr;
use ::payment_methods::controller::PaymentMethodsController;
use api_models::webhooks::WebhookResponseTracker;
use async_trait::async_trait;
use common_utils::{
crypto::Encryptable,
ext_traits::{AsyncExt, ByteSliceExt, ValueExt},
id_type,
};
use error_stack::{report, ResultExt};
use http::HeaderValue;
use masking::{ExposeInterface, Secret};
use serde::{Deserialize, Serialize};
use crate::{
configs::settings,
core::{
errors::{self, CustomResult, RouterResult, StorageErrorExt},
payment_methods::cards,
},
logger,
routes::{app::SessionStateInfo, SessionState},
types::{
api, domain, payment_methods as pm_types,
storage::{self, enums},
},
utils::{self as helper_utils, ext_traits::OptionExt},
};
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
pub enum NetworkTokenWebhookResponse {
PanMetadataUpdate(pm_types::PanMetadataUpdateBody),
NetworkTokenMetadataUpdate(pm_types::NetworkTokenMetaDataUpdateBody),
}
impl NetworkTokenWebhookResponse {
fn get_network_token_requestor_ref_id(&self) -> String {
match self {
Self::PanMetadataUpdate(data) => data.card.card_reference.clone(),
Self::NetworkTokenMetadataUpdate(data) => data.token.card_reference.clone(),
}
}
pub fn get_response_data(self) -> Box<dyn NetworkTokenWebhookResponseExt> {
match self {
Self::PanMetadataUpdate(data) => Box::new(data),
Self::NetworkTokenMetadataUpdate(data) => Box::new(data),
}
}
pub async fn fetch_merchant_id_payment_method_id_customer_id_from_callback_mapper(
&self,
state: &SessionState,
) -> RouterResult<(id_type::MerchantId, String, id_type::CustomerId)> {
let network_token_requestor_ref_id = &self.get_network_token_requestor_ref_id();
let db = &*state.store;
let callback_mapper_data = db
.find_call_back_mapper_by_id(network_token_requestor_ref_id)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed to fetch callback mapper data")?;
Ok(callback_mapper_data
.data
.get_network_token_webhook_details())
}
}
pub fn get_network_token_resource_object(
request_details: &api::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<Box<dyn masking::ErasedMaskSerialize>, errors::NetworkTokenizationError> {
let response: NetworkTokenWebhookResponse = request_details
.body
.parse_struct("NetworkTokenWebhookResponse")
.change_context(errors::NetworkTokenizationError::ResponseDeserializationFailed)?;
Ok(Box::new(response))
}
#[async_trait]
pub trait NetworkTokenWebhookResponseExt {
fn decrypt_payment_method_data(
&self,
payment_method: &domain::PaymentMethod,
) -> CustomResult<api::payment_methods::CardDetailFromLocker, errors::ApiErrorResponse>;
async fn update_payment_method(
&self,
state: &SessionState,
payment_method: &domain::PaymentMethod,
platform: &domain::Platform,
) -> CustomResult<WebhookResponseTracker, errors::ApiErrorResponse>;
}
#[async_trait]
impl NetworkTokenWebhookResponseExt for pm_types::PanMetadataUpdateBody {
fn decrypt_payment_method_data(
&self,
payment_method: &domain::PaymentMethod,
) -> CustomResult<api::payment_methods::CardDetailFromLocker, errors::ApiErrorResponse> {
let decrypted_data = payment_method
.payment_method_data
.clone()
.map(|payment_method_data| payment_method_data.into_inner().expose())
.and_then(|val| {
val.parse_value::<api::payment_methods::PaymentMethodsData>("PaymentMethodsData")
.map_err(|err| logger::error!(?err, "Failed to parse PaymentMethodsData"))
.ok()
})
.and_then(|pmd| match pmd {
api::payment_methods::PaymentMethodsData::Card(token) => {
Some(api::payment_methods::CardDetailFromLocker::from(token))
}
_ => None,
})
.ok_or(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed to obtain decrypted token object from db")?;
Ok(decrypted_data)
}
async fn update_payment_method(
&self,
state: &SessionState,
payment_method: &domain::PaymentMethod,
platform: &domain::Platform,
) -> CustomResult<WebhookResponseTracker, errors::ApiErrorResponse> {
let decrypted_data = self.decrypt_payment_method_data(payment_method)?;
handle_metadata_update(
state,
&self.card,
payment_method
.locker_id
.clone()
.get_required_value("locker_id")
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Locker id is not found for the payment method")?,
payment_method,
platform,
decrypted_data,
true,
)
.await
}
}
#[async_trait]
impl NetworkTokenWebhookResponseExt for pm_types::NetworkTokenMetaDataUpdateBody {
fn decrypt_payment_method_data(
&self,
payment_method: &domain::PaymentMethod,
) -> CustomResult<api::payment_methods::CardDetailFromLocker, errors::ApiErrorResponse> {
let decrypted_data = payment_method
.network_token_payment_method_data
.clone()
.map(|x| x.into_inner().expose())
.and_then(|val| {
val.parse_value::<api::payment_methods::PaymentMethodsData>("PaymentMethodsData")
.map_err(|err| logger::error!(?err, "Failed to parse PaymentMethodsData"))
.ok()
})
.and_then(|pmd| match pmd {
api::payment_methods::PaymentMethodsData::Card(token) => {
Some(api::payment_methods::CardDetailFromLocker::from(token))
}
_ => None,
})
.ok_or(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed to obtain decrypted token object from db")?;
Ok(decrypted_data)
}
async fn update_payment_method(
&self,
state: &SessionState,
payment_method: &domain::PaymentMethod,
platform: &domain::Platform,
) -> CustomResult<WebhookResponseTracker, errors::ApiErrorResponse> {
let decrypted_data = self.decrypt_payment_method_data(payment_method)?;
handle_metadata_update(
state,
&self.token,
payment_method
.network_token_locker_id
.clone()
.get_required_value("locker_id")
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Locker id is not found for the payment method")?,
payment_method,
platform,
decrypted_data,
true,
)
.await
}
}
pub struct Authorization {
header: Option<HeaderValue>,
}
impl Authorization {
pub fn new(header: Option<&HeaderValue>) -> Self {
Self {
header: header.cloned(),
}
}
pub async fn verify_webhook_source(
self,
nt_service: &settings::NetworkTokenizationService,
) -> CustomResult<(), errors::ApiErrorResponse> {
let secret = nt_service.webhook_source_verification_key.clone();
let source_verified = match self.header {
Some(authorization_header) => match authorization_header.to_str() {
Ok(header_value) => Ok(header_value == secret.expose()),
Err(err) => {
logger::error!(?err, "Failed to parse authorization header");
Err(errors::ApiErrorResponse::WebhookAuthenticationFailed)
}
},
None => Ok(false),
}?;
logger::info!(source_verified=?source_verified);
helper_utils::when(!source_verified, || {
Err(report!(
errors::ApiErrorResponse::WebhookAuthenticationFailed
))
})?;
Ok(())
}
}
#[allow(clippy::too_many_arguments)]
pub async fn handle_metadata_update(
state: &SessionState,
metadata: &pm_types::NetworkTokenRequestorData,
locker_id: String,
payment_method: &domain::PaymentMethod,
platform: &domain::Platform,
decrypted_data: api::payment_methods::CardDetailFromLocker,
is_pan_update: bool,
) -> RouterResult<WebhookResponseTracker> {
let merchant_id = platform.get_processor().get_account().get_id();
let customer_id = &payment_method.customer_id;
let payment_method_id = payment_method.get_id().clone();
let status = payment_method.status;
match metadata.is_update_required(decrypted_data) {
false => {
logger::info!(
"No update required for payment method {} for locker_id {}",
payment_method.get_id(),
locker_id
);
Ok(WebhookResponseTracker::PaymentMethod {
payment_method_id,
status,
})
}
true => {
let mut card = cards::get_card_from_locker(state, customer_id, merchant_id, &locker_id)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed to fetch token information from the locker")?
.get_card();
card.card_exp_year = metadata.expiry_year.clone();
card.card_exp_month = metadata.expiry_month.clone();
let card_network = card
.card_brand
.clone()
.map(|card_brand| enums::CardNetwork::from_str(&card_brand))
.transpose()
.change_context(errors::ApiErrorResponse::InvalidDataValue {
field_name: "card network",
})
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Invalid Card Network stored in vault")?;
let card_data = api::payment_methods::CardDetail::from((card, card_network));
let payment_method_request: api::payment_methods::PaymentMethodCreate =
PaymentMethodCreateWrapper::from((&card_data, payment_method)).get_inner();
let pm_cards = cards::PmCards {
state,
provider: platform.get_provider(),
};
pm_cards
.delete_card_from_locker(customer_id, merchant_id, &locker_id)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed to delete network token")?;
let (res, _) = pm_cards
.add_card_to_locker(payment_method_request, &card_data, customer_id, None)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed to add network token")?;
let pm_details = res.card.as_ref().map(|card| {
api::payment_methods::PaymentMethodsData::Card(
api::payment_methods::CardDetailsPaymentMethod::from((card.clone(), None)),
)
});
let key_manager_state = state.into();
let pm_data_encrypted: Option<Encryptable<Secret<serde_json::Value>>> = pm_details
.async_map(|pm_card| {
cards::create_encrypted_data(
&key_manager_state,
platform.get_processor().get_key_store(),
pm_card,
)
})
.await
.transpose()
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Unable to encrypt payment method data")?;
let pm_update = if is_pan_update {
storage::PaymentMethodUpdate::AdditionalDataUpdate {
locker_id: Some(res.payment_method_id),
payment_method_data: pm_data_encrypted.map(Into::into),
status: None,
payment_method: None,
payment_method_type: None,
payment_method_issuer: None,
network_token_requestor_reference_id: None,
network_token_locker_id: None,
network_token_payment_method_data: None,
last_modified_by: None,
}
} else {
storage::PaymentMethodUpdate::AdditionalDataUpdate {
locker_id: None,
payment_method_data: None,
status: None,
payment_method: None,
payment_method_type: None,
payment_method_issuer: None,
network_token_requestor_reference_id: None,
network_token_locker_id: Some(res.payment_method_id),
network_token_payment_method_data: pm_data_encrypted.map(Into::into),
last_modified_by: None,
}
};
let db = &*state.store;
db.update_payment_method(
platform.get_processor().get_key_store(),
payment_method.clone(),
pm_update,
platform.get_processor().get_account().storage_scheme,
)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed to update the payment method")?;
Ok(WebhookResponseTracker::PaymentMethod {
payment_method_id,
status,
})
}
}
}
pub struct PaymentMethodCreateWrapper(pub api::payment_methods::PaymentMethodCreate);
impl From<(&api::payment_methods::CardDetail, &domain::PaymentMethod)>
for PaymentMethodCreateWrapper
{
fn from(
(data, payment_method): (&api::payment_methods::CardDetail, &domain::PaymentMethod),
) -> Self {
Self(api::payment_methods::PaymentMethodCreate {
customer_id: Some(payment_method.customer_id.clone()),
payment_method: payment_method.payment_method,
payment_method_type: payment_method.payment_method_type,
payment_method_issuer: payment_method.payment_method_issuer.clone(),
payment_method_issuer_code: payment_method.payment_method_issuer_code,
metadata: payment_method.metadata.clone(),
payment_method_data: None,
connector_mandate_details: None,
client_secret: None,
billing: None,
card: Some(data.clone()),
card_network: data
.card_network
.clone()
.map(|card_network| card_network.to_string()),
bank_transfer: None,
wallet: None,
network_transaction_id: payment_method.network_transaction_id.clone(),
})
}
}
impl PaymentMethodCreateWrapper {
fn get_inner(self) -> api::payment_methods::PaymentMethodCreate {
self.0
}
}
pub async fn fetch_merchant_account_for_network_token_webhooks(
state: &SessionState,
merchant_id: &id_type::MerchantId,
) -> RouterResult<domain::Platform> {
let db = &*state.store;
let key_store = state
.store()
.get_merchant_key_store_by_merchant_id(
merchant_id,
&state.store().get_master_key().to_vec().into(),
)
.await
.change_context(errors::ApiErrorResponse::Unauthorized)
.attach_printable("Failed to fetch merchant key store for the merchant id")?;
let merchant_account = db
.find_merchant_account_by_merchant_id(merchant_id, &key_store)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed to fetch merchant account for the merchant id")?;
let platform = domain::Platform::new(
merchant_account.clone(),
key_store.clone(),
merchant_account,
key_store,
None,
);
Ok(platform)
}
pub async fn fetch_payment_method_for_network_token_webhooks(
state: &SessionState,
merchant_account: &domain::MerchantAccount,
key_store: &domain::MerchantKeyStore,
payment_method_id: &str,
) -> RouterResult<domain::PaymentMethod> {
let db = &*state.store;
let payment_method = db
.find_payment_method(
key_store,
payment_method_id,
merchant_account.storage_scheme,
)
.await
.to_not_found_response(errors::ApiErrorResponse::WebhookResourceNotFound)
.attach_printable("Failed to fetch the payment method")?;
Ok(payment_method)
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/webhooks/types.rs | crates/router/src/core/webhooks/types.rs | use api_models::{webhook_events, webhooks};
use common_utils::{crypto::SignMessage, ext_traits::Encode};
use error_stack::ResultExt;
use masking::Secret;
use serde::Serialize;
use crate::{
core::errors,
headers, logger,
services::request::Maskable,
types::storage::{self, enums},
};
#[derive(Debug)]
pub enum ScheduleWebhookRetry {
WithProcessTracker(Box<storage::ProcessTracker>),
NoSchedule,
}
pub struct OutgoingWebhookPayloadWithSignature {
pub payload: Secret<String>,
pub signature: Option<String>,
}
pub trait OutgoingWebhookType:
Serialize + From<webhooks::OutgoingWebhook> + Sync + Send + std::fmt::Debug + 'static
{
fn get_outgoing_webhooks_signature(
&self,
payment_response_hash_key: Option<impl AsRef<[u8]>>,
) -> errors::CustomResult<OutgoingWebhookPayloadWithSignature, errors::WebhooksFlowError>;
fn add_webhook_header(header: &mut Vec<(String, Maskable<String>)>, signature: String);
}
impl OutgoingWebhookType for webhooks::OutgoingWebhook {
fn get_outgoing_webhooks_signature(
&self,
payment_response_hash_key: Option<impl AsRef<[u8]>>,
) -> errors::CustomResult<OutgoingWebhookPayloadWithSignature, errors::WebhooksFlowError> {
let webhook_signature_payload = self
.encode_to_string_of_json()
.change_context(errors::WebhooksFlowError::OutgoingWebhookEncodingFailed)
.attach_printable("failed encoding outgoing webhook payload")?;
let signature = payment_response_hash_key
.map(|key| {
common_utils::crypto::HmacSha512::sign_message(
&common_utils::crypto::HmacSha512,
key.as_ref(),
webhook_signature_payload.as_bytes(),
)
})
.transpose()
.change_context(errors::WebhooksFlowError::OutgoingWebhookSigningFailed)
.attach_printable("Failed to sign the message")?
.map(hex::encode);
Ok(OutgoingWebhookPayloadWithSignature {
payload: webhook_signature_payload.into(),
signature,
})
}
fn add_webhook_header(header: &mut Vec<(String, Maskable<String>)>, signature: String) {
header.push((headers::X_WEBHOOK_SIGNATURE.to_string(), signature.into()))
}
}
#[derive(Debug, serde::Serialize, serde::Deserialize)]
pub(crate) struct OutgoingWebhookTrackingData {
pub(crate) merchant_id: common_utils::id_type::MerchantId,
pub(crate) business_profile_id: common_utils::id_type::ProfileId,
pub(crate) event_type: enums::EventType,
pub(crate) event_class: enums::EventClass,
pub(crate) primary_object_id: String,
pub(crate) primary_object_type: enums::EventObjectType,
pub(crate) initial_attempt_id: Option<String>,
}
pub struct WebhookResponse {
pub response: reqwest::Response,
}
impl WebhookResponse {
pub async fn get_outgoing_webhook_response_content(
self,
) -> webhook_events::OutgoingWebhookResponseContent {
let status_code = self.response.status();
let response_headers = self
.response
.headers()
.iter()
.map(|(name, value)| {
(
name.as_str().to_owned(),
value
.to_str()
.map(|s| Secret::from(String::from(s)))
.unwrap_or_else(|error| {
logger::warn!(
"Response header {} contains non-UTF-8 characters: {error:?}",
name.as_str()
);
Secret::from(String::from("Non-UTF-8 header value"))
}),
)
})
.collect::<Vec<_>>();
let response_body = self
.response
.text()
.await
.map(Secret::from)
.unwrap_or_else(|error| {
logger::warn!("Response contains non-UTF-8 characters: {error:?}");
Secret::from(String::from("Non-UTF-8 response body"))
});
webhook_events::OutgoingWebhookResponseContent {
body: Some(response_body),
headers: Some(response_headers),
status_code: Some(status_code.as_u16()),
error_message: None,
}
}
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/webhooks/utils.rs | crates/router/src/core/webhooks/utils.rs | use std::marker::PhantomData;
use base64::Engine;
use common_utils::{
consts,
crypto::{self, GenerateDigest},
errors::CustomResult,
ext_traits::ValueExt,
};
use error_stack::{Report, ResultExt};
use redis_interface as redis;
use router_env::tracing;
use super::MERCHANT_ID;
use crate::{
core::{
errors::{self},
metrics,
payments::helpers,
},
db::{get_and_deserialize_key, StorageInterface},
errors::RouterResult,
routes::app::SessionStateInfo,
services::logger,
types::{self, api, domain, PaymentAddress},
SessionState,
};
const IRRELEVANT_ATTEMPT_ID_IN_SOURCE_VERIFICATION_FLOW: &str =
"irrelevant_attempt_id_in_source_verification_flow";
const IRRELEVANT_CONNECTOR_REQUEST_REFERENCE_ID_IN_SOURCE_VERIFICATION_FLOW: &str =
"irrelevant_connector_request_reference_id_in_source_verification_flow";
/// Check whether the merchant has configured to disable the webhook `event` for the `connector`
/// First check for the key "whconf_{merchant_id}_{connector_id}" in redis,
/// if not found, fetch from configs table in database
pub async fn is_webhook_event_disabled(
db: &dyn StorageInterface,
connector_id: &str,
merchant_id: &common_utils::id_type::MerchantId,
event: &api::IncomingWebhookEvent,
) -> bool {
let redis_key = merchant_id.get_webhook_config_disabled_events_key(connector_id);
let merchant_webhook_disable_config_result: CustomResult<
api::MerchantWebhookConfig,
redis_interface::errors::RedisError,
> = get_and_deserialize_key(db, &redis_key, "MerchantWebhookConfig").await;
match merchant_webhook_disable_config_result {
Ok(merchant_webhook_config) => merchant_webhook_config.contains(event),
Err(..) => {
//if failed to fetch from redis. fetch from db and populate redis
db.find_config_by_key(&redis_key)
.await
.map(|config| {
match serde_json::from_str::<api::MerchantWebhookConfig>(&config.config) {
Ok(set) => set.contains(event),
Err(err) => {
logger::warn!(?err, "error while parsing merchant webhook config");
false
}
}
})
.unwrap_or_else(|err| {
logger::warn!(?err, "error while fetching merchant webhook config");
false
})
}
}
}
pub async fn construct_webhook_router_data(
state: &SessionState,
connector_name: &str,
merchant_connector_account: domain::MerchantConnectorAccount,
platform: &domain::Platform,
connector_wh_secrets: &api_models::webhooks::ConnectorWebhookSecrets,
request_details: &api::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<types::VerifyWebhookSourceRouterData, errors::ApiErrorResponse> {
let auth_type: types::ConnectorAuthType =
helpers::MerchantConnectorAccountType::DbVal(Box::new(merchant_connector_account.clone()))
.get_connector_account_details()
.parse_value("ConnectorAuthType")
.change_context(errors::ApiErrorResponse::InternalServerError)?;
let router_data = types::RouterData {
flow: PhantomData,
merchant_id: platform.get_processor().get_account().get_id().clone(),
connector: connector_name.to_string(),
customer_id: None,
tenant_id: state.tenant.tenant_id.clone(),
payment_id: common_utils::id_type::PaymentId::get_irrelevant_id("source_verification_flow")
.get_string_repr()
.to_owned(),
attempt_id: IRRELEVANT_ATTEMPT_ID_IN_SOURCE_VERIFICATION_FLOW.to_string(),
status: diesel_models::enums::AttemptStatus::default(),
payment_method: diesel_models::enums::PaymentMethod::default(),
payment_method_type: None,
connector_auth_type: auth_type,
description: None,
address: PaymentAddress::default(),
auth_type: diesel_models::enums::AuthenticationType::default(),
connector_meta_data: None,
connector_wallets_details: None,
amount_captured: None,
minor_amount_captured: None,
request: types::VerifyWebhookSourceRequestData {
webhook_headers: request_details.headers.clone(),
webhook_body: request_details.body.to_vec().clone(),
merchant_secret: connector_wh_secrets.to_owned(),
},
response: Err(types::ErrorResponse::default()),
access_token: None,
session_token: None,
reference_id: None,
payment_method_token: None,
connector_customer: None,
recurring_mandate_payment_data: None,
preprocessing_id: None,
connector_request_reference_id:
IRRELEVANT_CONNECTOR_REQUEST_REFERENCE_ID_IN_SOURCE_VERIFICATION_FLOW.to_string(),
#[cfg(feature = "payouts")]
payout_method_data: None,
#[cfg(feature = "payouts")]
quote_id: None,
test_mode: None,
payment_method_balance: None,
payment_method_status: None,
connector_api_version: None,
connector_http_status_code: None,
external_latency: None,
apple_pay_flow: None,
frm_metadata: None,
refund_id: None,
dispute_id: None,
payout_id: None,
connector_response: None,
integrity_check: Ok(()),
additional_merchant_data: None,
header_payload: None,
connector_mandate_request_reference_id: None,
authentication_id: None,
psd2_sca_exemption_type: None,
raw_connector_response: None,
is_payment_id_from_merchant: None,
l2_l3_data: None,
minor_amount_capturable: None,
authorized_amount: None,
};
Ok(router_data)
}
#[inline]
pub(crate) fn get_idempotent_event_id(
primary_object_id: &str,
event_type: types::storage::enums::EventType,
delivery_attempt: types::storage::enums::WebhookDeliveryAttempt,
) -> Result<String, Report<errors::WebhooksFlowError>> {
use crate::types::storage::enums::WebhookDeliveryAttempt;
const EVENT_ID_SUFFIX_LENGTH: usize = 8;
let common_prefix = format!("{primary_object_id}_{event_type}");
// Hash the common prefix with SHA256 and encode with URL-safe base64 without padding
let digest = crypto::Sha256
.generate_digest(common_prefix.as_bytes())
.change_context(errors::WebhooksFlowError::IdGenerationFailed)
.attach_printable("Failed to generate idempotent event ID")?;
let base_encoded = consts::BASE64_ENGINE_URL_SAFE_NO_PAD.encode(digest);
let result = match delivery_attempt {
WebhookDeliveryAttempt::InitialAttempt => base_encoded,
WebhookDeliveryAttempt::AutomaticRetry | WebhookDeliveryAttempt::ManualRetry => {
common_utils::generate_id(EVENT_ID_SUFFIX_LENGTH, &base_encoded)
}
};
Ok(result)
}
#[inline]
pub(crate) fn generate_event_id() -> String {
common_utils::generate_time_ordered_id("evt")
}
pub fn increment_webhook_outgoing_received_count(merchant_id: &common_utils::id_type::MerchantId) {
metrics::WEBHOOK_OUTGOING_RECEIVED_COUNT.add(
1,
router_env::metric_attributes!((MERCHANT_ID, merchant_id.clone())),
)
}
pub fn increment_webhook_outgoing_not_received_count(
merchant_id: &common_utils::id_type::MerchantId,
) {
metrics::WEBHOOK_OUTGOING_NOT_RECEIVED_COUNT.add(
1,
router_env::metric_attributes!((MERCHANT_ID, merchant_id.clone())),
);
}
pub fn is_outgoing_webhook_disabled(
state: &SessionState,
webhook_url_result: &Result<String, Report<errors::WebhooksFlowError>>,
business_profile: &domain::Profile,
idempotent_event_id: &str,
) -> bool {
if !state.conf.webhooks.outgoing_enabled
|| webhook_url_result.is_err()
|| webhook_url_result.as_ref().is_ok_and(String::is_empty)
{
logger::debug!(
business_profile_id=?business_profile.get_id(),
%idempotent_event_id,
"Outgoing webhooks are disabled in application configuration, or merchant webhook URL \
could not be obtained; skipping outgoing webhooks for event"
);
return true;
}
false
}
const WEBHOOK_LOCK_PREFIX: &str = "WEBHOOK_LOCK";
pub(super) async fn perform_redis_lock<A>(
state: &A,
unique_locking_key: &str,
merchant_id: common_utils::id_type::MerchantId,
) -> RouterResult<Option<String>>
where
A: SessionStateInfo,
{
let lock_value: String = uuid::Uuid::new_v4().to_string();
let redis_conn = state
.store()
.get_redis_conn()
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Error connecting to redis")?;
let redis_locking_key = format!(
"{}_{}_{}",
WEBHOOK_LOCK_PREFIX,
merchant_id.get_string_repr(),
unique_locking_key
);
let redis_lock_expiry_seconds = state.conf().webhooks.redis_lock_expiry_seconds;
let redis_lock_result = redis_conn
.set_key_if_not_exists_with_expiry(
&redis_locking_key.as_str().into(),
lock_value.clone(),
Some(i64::from(redis_lock_expiry_seconds)),
)
.await;
match redis_lock_result {
Ok(redis::SetnxReply::KeySet) => {
logger::info!("Lock acquired for for {redis_locking_key}");
Ok(Some(lock_value))
}
Ok(redis::SetnxReply::KeyNotSet) => {
logger::info!("Lock already held for {redis_locking_key}");
Ok(None)
}
Err(err) => Err(err
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Error acquiring redis lock")),
}
}
pub(super) async fn free_redis_lock<A>(
state: &A,
unique_locking_key: &str,
merchant_id: common_utils::id_type::MerchantId,
lock_value: Option<String>,
) -> RouterResult<()>
where
A: SessionStateInfo,
{
let redis_conn = state
.store()
.get_redis_conn()
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Error connecting to redis")?;
let redis_locking_key = format!(
"{}_{}_{}",
WEBHOOK_LOCK_PREFIX,
merchant_id.get_string_repr(),
unique_locking_key
);
match redis_conn
.get_key::<Option<String>>(&redis_locking_key.as_str().into())
.await
{
Ok(val) => {
if val == lock_value {
match redis_conn
.delete_key(&redis_locking_key.as_str().into())
.await
{
Ok(redis::types::DelReply::KeyDeleted) => {
logger::info!("Lock freed {redis_locking_key}");
tracing::Span::current().record("redis_lock_released", redis_locking_key);
Ok(())
}
Ok(redis::types::DelReply::KeyNotDeleted) => Err(
errors::ApiErrorResponse::InternalServerError,
)
.attach_printable("Status release lock called but key is not found in redis"),
Err(error) => Err(error)
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Error while deleting redis key"),
}
} else {
Err(errors::ApiErrorResponse::InternalServerError)
.attach_printable("The redis value which acquired the lock is not equal to the redis value requesting for releasing the lock")
}
}
Err(error) => Err(error)
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Error while deleting redis key"),
}
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/webhooks/incoming_v2.rs | crates/router/src/core/webhooks/incoming_v2.rs | use std::{marker::PhantomData, str::FromStr, time::Instant};
use actix_web::FromRequest;
use api_models::webhooks::{self, WebhookResponseTracker};
use common_utils::{
errors::ReportSwitchExt, events::ApiEventsType, types::keymanager::KeyManagerState,
};
use error_stack::ResultExt;
use hyperswitch_domain_models::{
payments::{HeaderPayload, PaymentStatusData},
router_request_types::VerifyWebhookSourceRequestData,
router_response_types::{VerifyWebhookSourceResponseData, VerifyWebhookStatus},
};
use hyperswitch_interfaces::webhooks::IncomingWebhookRequestDetails;
use router_env::{instrument, tracing, RequestId};
use super::{types, utils, MERCHANT_ID};
#[cfg(feature = "revenue_recovery")]
use crate::core::webhooks::recovery_incoming;
use crate::{
core::{
api_locking,
errors::{self, ConnectorErrorExt, CustomResult, RouterResponse, StorageErrorExt},
metrics,
payments::{
self,
transformers::{GenerateResponse, ToResponse},
},
webhooks::{
create_event_and_trigger_outgoing_webhook, utils::construct_webhook_router_data,
},
},
db::StorageInterface,
events::api_logs::ApiEvent,
logger,
routes::{
app::{ReqState, SessionStateInfo},
lock_utils, SessionState,
},
services::{
self, authentication as auth, connector_integration_interface::ConnectorEnum,
ConnectorValidation,
},
types::{
api::{self, ConnectorData, GetToken, IncomingWebhook},
domain,
storage::enums,
transformers::ForeignInto,
},
};
#[allow(clippy::too_many_arguments)]
pub async fn incoming_webhooks_wrapper<W: types::OutgoingWebhookType>(
flow: &impl router_env::types::FlowMetric,
state: SessionState,
req_state: ReqState,
req: &actix_web::HttpRequest,
platform: domain::Platform,
profile: domain::Profile,
connector_id: &common_utils::id_type::MerchantConnectorAccountId,
body: actix_web::web::Bytes,
is_relay_webhook: bool,
) -> RouterResponse<serde_json::Value> {
let start_instant = Instant::now();
let (application_response, webhooks_response_tracker, serialized_req) =
Box::pin(incoming_webhooks_core::<W>(
state.clone(),
req_state,
req,
platform.clone(),
profile,
connector_id,
body.clone(),
is_relay_webhook,
))
.await?;
logger::info!(incoming_webhook_payload = ?serialized_req);
let request_duration = Instant::now()
.saturating_duration_since(start_instant)
.as_millis();
let request_id = RequestId::extract(req)
.await
.attach_printable("Unable to extract request id from request")
.change_context(errors::ApiErrorResponse::InternalServerError)?;
let auth_type = auth::AuthenticationType::WebhookAuth {
merchant_id: platform.get_processor().get_account().get_id().clone(),
};
let status_code = 200;
let api_event = ApiEventsType::Webhooks {
connector: connector_id.clone(),
payment_id: webhooks_response_tracker.get_payment_id(),
refund_id: webhooks_response_tracker.get_refund_id(),
};
let response_value = serde_json::to_value(&webhooks_response_tracker)
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Could not convert webhook effect to string")?;
let infra = state.infra_components.clone();
let api_event = ApiEvent::new(
state.tenant.tenant_id.clone(),
Some(platform.get_processor().get_account().get_id().clone()),
flow,
&request_id,
request_duration,
status_code,
serialized_req,
Some(response_value),
None,
auth_type,
None,
api_event,
req,
req.method(),
infra,
);
state.event_handler().log_event(&api_event);
Ok(application_response)
}
#[instrument(skip_all)]
#[allow(clippy::too_many_arguments)]
async fn incoming_webhooks_core<W: types::OutgoingWebhookType>(
state: SessionState,
req_state: ReqState,
req: &actix_web::HttpRequest,
platform: domain::Platform,
profile: domain::Profile,
connector_id: &common_utils::id_type::MerchantConnectorAccountId,
body: actix_web::web::Bytes,
_is_relay_webhook: bool,
) -> errors::RouterResult<(
services::ApplicationResponse<serde_json::Value>,
WebhookResponseTracker,
serde_json::Value,
)> {
metrics::WEBHOOK_INCOMING_COUNT.add(
1,
router_env::metric_attributes!((
MERCHANT_ID,
platform.get_processor().get_account().get_id().clone()
)),
);
let mut request_details = IncomingWebhookRequestDetails {
method: req.method().clone(),
uri: req.uri().clone(),
headers: req.headers(),
query_params: req.query_string().to_string(),
body: &body,
};
// Fetch the merchant connector account to get the webhooks source secret
// `webhooks source secret` is a secret shared between the merchant and connector
// This is used for source verification and webhooks integrity
let (merchant_connector_account, connector, connector_name) = fetch_mca_and_connector(
&state,
connector_id,
platform.get_processor().get_key_store(),
)
.await?;
let decoded_body = connector
.decode_webhook_body(
&request_details,
platform.get_processor().get_account().get_id(),
merchant_connector_account.connector_webhook_details.clone(),
connector_name.as_str(),
)
.await
.switch()
.attach_printable("There was an error in incoming webhook body decoding")?;
request_details.body = &decoded_body;
let event_type = match connector
.get_webhook_event_type(&request_details)
.allow_webhook_event_type_not_found(
state
.clone()
.conf
.webhooks
.ignore_error
.event_type
.unwrap_or(true),
)
.switch()
.attach_printable("Could not find event type in incoming webhook body")?
{
Some(event_type) => event_type,
// Early return allows us to acknowledge the webhooks that we do not support
None => {
logger::error!(
webhook_payload =? request_details.body,
"Failed while identifying the event type",
);
metrics::WEBHOOK_EVENT_TYPE_IDENTIFICATION_FAILURE_COUNT.add(
1,
router_env::metric_attributes!(
(
MERCHANT_ID,
platform.get_processor().get_account().get_id().clone()
),
("connector", connector_name)
),
);
let response = connector
.get_webhook_api_response(&request_details, None)
.switch()
.attach_printable("Failed while early return in case of event type parsing")?;
return Ok((
response,
WebhookResponseTracker::NoEffect,
serde_json::Value::Null,
));
}
};
logger::info!(event_type=?event_type);
// if it is a setup webhook event, return ok status
if event_type == webhooks::IncomingWebhookEvent::SetupWebhook {
return Ok((
services::ApplicationResponse::StatusOk,
WebhookResponseTracker::NoEffect,
serde_json::Value::default(),
));
}
let is_webhook_event_supported = !matches!(
event_type,
webhooks::IncomingWebhookEvent::EventNotSupported
);
let is_webhook_event_enabled = !utils::is_webhook_event_disabled(
&*state.clone().store,
connector_name.as_str(),
platform.get_processor().get_account().get_id(),
&event_type,
)
.await;
//process webhook further only if webhook event is enabled and is not event_not_supported
let process_webhook_further = is_webhook_event_enabled && is_webhook_event_supported;
logger::info!(process_webhook=?process_webhook_further);
let flow_type: api::WebhookFlow = event_type.into();
let mut event_object: Box<dyn masking::ErasedMaskSerialize> = Box::new(serde_json::Value::Null);
let webhook_effect = if process_webhook_further
&& !matches!(flow_type, api::WebhookFlow::ReturnResponse)
{
let object_ref_id = connector
.get_webhook_object_reference_id(&request_details)
.switch()
.attach_printable("Could not find object reference id in incoming webhook body")?;
let connector_enum = api_models::enums::Connector::from_str(&connector_name)
.change_context(errors::ApiErrorResponse::InvalidDataValue {
field_name: "connector",
})
.attach_printable_lazy(|| {
format!("unable to parse connector name {connector_name:?}")
})?;
let connectors_with_source_verification_call = &state.conf.webhook_source_verification_call;
let source_verified = if connectors_with_source_verification_call
.connectors_with_webhook_source_verification_call
.contains(&connector_enum)
{
verify_webhook_source_verification_call(
connector.clone(),
&state,
&platform,
merchant_connector_account.clone(),
&connector_name,
&request_details,
)
.await
.or_else(|error| match error.current_context() {
errors::ConnectorError::WebhookSourceVerificationFailed => {
logger::error!(?error, "Source Verification Failed");
Ok(false)
}
_ => Err(error),
})
.switch()
.attach_printable("There was an issue in incoming webhook source verification")?
} else {
connector
.clone()
.verify_webhook_source(
&request_details,
platform.get_processor().get_account().get_id(),
merchant_connector_account.connector_webhook_details.clone(),
merchant_connector_account.connector_account_details.clone(),
connector_name.as_str(),
)
.await
.or_else(|error| match error.current_context() {
errors::ConnectorError::WebhookSourceVerificationFailed => {
logger::error!(?error, "Source Verification Failed");
Ok(false)
}
_ => Err(error),
})
.switch()
.attach_printable("There was an issue in incoming webhook source verification")?
};
logger::info!(source_verified=?source_verified);
if source_verified {
metrics::WEBHOOK_SOURCE_VERIFIED_COUNT.add(
1,
router_env::metric_attributes!((
MERCHANT_ID,
platform.get_processor().get_account().get_id().clone()
)),
);
}
// If source verification is mandatory and source is not verified, fail with webhook authentication error
// else continue the flow
match (
connector.is_webhook_source_verification_mandatory(),
source_verified,
) {
(true, false) => Err(errors::ApiErrorResponse::WebhookAuthenticationFailed)?,
_ => {
event_object = connector
.get_webhook_resource_object(&request_details)
.switch()
.attach_printable("Could not find resource object in incoming webhook body")?;
let webhook_details = api::IncomingWebhookDetails {
object_reference_id: object_ref_id.clone(),
resource_object: serde_json::to_vec(&event_object)
.change_context(errors::ParsingError::EncodeError("byte-vec"))
.attach_printable("Unable to convert webhook payload to a value")
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable(
"There was an issue when encoding the incoming webhook body to bytes",
)?,
};
match flow_type {
api::WebhookFlow::Payment => Box::pin(payments_incoming_webhook_flow(
state.clone(),
req_state,
platform,
profile,
webhook_details,
source_verified,
))
.await
.attach_printable("Incoming webhook flow for payments failed")?,
api::WebhookFlow::Refund => todo!(),
api::WebhookFlow::Dispute => todo!(),
api::WebhookFlow::BankTransfer => todo!(),
api::WebhookFlow::ReturnResponse => WebhookResponseTracker::NoEffect,
api::WebhookFlow::Mandate => todo!(),
api::WebhookFlow::ExternalAuthentication => todo!(),
api::WebhookFlow::FraudCheck => todo!(),
api::WebhookFlow::Setup => WebhookResponseTracker::NoEffect,
#[cfg(feature = "payouts")]
api::WebhookFlow::Payout => todo!(),
api::WebhookFlow::Subscription => todo!(),
#[cfg(all(feature = "revenue_recovery", feature = "v2"))]
api::WebhookFlow::Recovery => {
Box::pin(recovery_incoming::recovery_incoming_webhook_flow(
state.clone(),
platform,
profile,
source_verified,
&connector,
merchant_connector_account,
&connector_name,
&request_details,
event_type,
req_state,
&object_ref_id,
))
.await
.change_context(errors::ApiErrorResponse::WebhookProcessingFailure)
.attach_printable("Failed to process recovery incoming webhook")?
}
}
}
}
} else {
metrics::WEBHOOK_INCOMING_FILTERED_COUNT.add(
1,
router_env::metric_attributes!((
MERCHANT_ID,
platform.get_processor().get_account().get_id().clone()
)),
);
WebhookResponseTracker::NoEffect
};
let response = connector
.get_webhook_api_response(&request_details, None)
.switch()
.attach_printable("Could not get incoming webhook api response from connector")?;
let serialized_request = event_object
.masked_serialize()
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Could not convert webhook effect to string")?;
Ok((response, webhook_effect, serialized_request))
}
#[instrument(skip_all)]
async fn payments_incoming_webhook_flow(
state: SessionState,
req_state: ReqState,
platform: domain::Platform,
profile: domain::Profile,
webhook_details: api::IncomingWebhookDetails,
source_verified: bool,
) -> CustomResult<WebhookResponseTracker, errors::ApiErrorResponse> {
let consume_or_trigger_flow = if source_verified {
payments::CallConnectorAction::HandleResponse(webhook_details.resource_object)
} else {
payments::CallConnectorAction::Trigger
};
let key_manager_state = &(&state).into();
let payments_response = match webhook_details.object_reference_id {
webhooks::ObjectReferenceId::PaymentId(id) => {
let get_trackers_response = get_trackers_response_for_payment_get_operation(
state.store.as_ref(),
&id,
profile.get_id(),
key_manager_state,
platform.get_processor().get_key_store(),
platform.get_processor().get_account().storage_scheme,
)
.await?;
let payment_id = get_trackers_response.payment_data.get_payment_id();
let lock_action = api_locking::LockAction::Hold {
input: api_locking::LockingInput {
unique_locking_key: payment_id.get_string_repr().to_owned(),
api_identifier: lock_utils::ApiIdentifier::Payments,
override_lock_retries: None,
},
};
lock_action
.clone()
.perform_locking_action(
&state,
platform.get_processor().get_account().get_id().to_owned(),
)
.await?;
let (
payment_data,
_req,
customer,
connector_http_status_code,
external_latency,
connector_response_data,
) = Box::pin(payments::payments_operation_core::<
api::PSync,
_,
_,
_,
PaymentStatusData<api::PSync>,
>(
&state,
req_state,
platform.clone(),
&profile,
payments::operations::PaymentGet,
api::PaymentsRetrieveRequest {
force_sync: true,
expand_attempts: false,
param: None,
return_raw_connector_response: None,
merchant_connector_details: None,
},
get_trackers_response,
consume_or_trigger_flow,
HeaderPayload::default(),
))
.await?;
let response = payment_data.generate_response(
&state,
connector_http_status_code,
external_latency,
None,
&platform,
&profile,
Some(connector_response_data),
);
lock_action
.free_lock_action(
&state,
platform.get_processor().get_account().get_id().to_owned(),
)
.await?;
match response {
Ok(value) => value,
Err(err)
if matches!(
err.current_context(),
&errors::ApiErrorResponse::PaymentNotFound
) && state
.clone()
.conf
.webhooks
.ignore_error
.payment_not_found
.unwrap_or(true) =>
{
metrics::WEBHOOK_PAYMENT_NOT_FOUND.add(
1,
router_env::metric_attributes!((
"merchant_id",
platform.get_processor().get_account().get_id().clone()
)),
);
return Ok(WebhookResponseTracker::NoEffect);
}
error @ Err(_) => error?,
}
}
_ => Err(errors::ApiErrorResponse::WebhookProcessingFailure).attach_printable(
"Did not get payment id as object reference id in webhook payments flow",
)?,
};
match payments_response {
services::ApplicationResponse::JsonWithHeaders((payments_response, _)) => {
let payment_id = payments_response.id.clone();
let status = payments_response.status;
let event_type: Option<enums::EventType> = payments_response.status.into();
// If event is NOT an UnsupportedEvent, trigger Outgoing Webhook
if let Some(outgoing_event_type) = event_type {
let primary_object_created_at = payments_response.created;
// TODO: trigger an outgoing webhook to merchant
Box::pin(create_event_and_trigger_outgoing_webhook(
state,
profile,
platform.get_processor().get_key_store(),
outgoing_event_type,
enums::EventClass::Payments,
payment_id.get_string_repr().to_owned(),
enums::EventObjectType::PaymentDetails,
api::OutgoingWebhookContent::PaymentDetails(Box::new(payments_response)),
primary_object_created_at,
))
.await?;
};
let response = WebhookResponseTracker::Payment { payment_id, status };
Ok(response)
}
_ => Err(errors::ApiErrorResponse::WebhookProcessingFailure)
.attach_printable("received non-json response from payments core")?,
}
}
async fn get_trackers_response_for_payment_get_operation<F>(
db: &dyn StorageInterface,
payment_id: &api::PaymentIdType,
profile_id: &common_utils::id_type::ProfileId,
key_manager_state: &KeyManagerState,
merchant_key_store: &domain::MerchantKeyStore,
storage_scheme: enums::MerchantStorageScheme,
) -> errors::RouterResult<payments::operations::GetTrackerResponse<PaymentStatusData<F>>>
where
F: Clone,
{
let (payment_intent, payment_attempt) = match payment_id {
api_models::payments::PaymentIdType::PaymentIntentId(ref id) => {
let payment_intent = db
.find_payment_intent_by_id(id, merchant_key_store, storage_scheme)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
let payment_attempt = db
.find_payment_attempt_by_id(
merchant_key_store,
&payment_intent
.active_attempt_id
.clone()
.ok_or(errors::ApiErrorResponse::InternalServerError)
.attach_printable("active_attempt_id not present in payment_attempt")?,
storage_scheme,
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
(payment_intent, payment_attempt)
}
api_models::payments::PaymentIdType::ConnectorTransactionId(ref id) => {
let payment_attempt = db
.find_payment_attempt_by_profile_id_connector_transaction_id(
merchant_key_store,
profile_id,
id,
storage_scheme,
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
let payment_intent = db
.find_payment_intent_by_id(
&payment_attempt.payment_id,
merchant_key_store,
storage_scheme,
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
(payment_intent, payment_attempt)
}
api_models::payments::PaymentIdType::PaymentAttemptId(ref id) => {
let global_attempt_id = common_utils::id_type::GlobalAttemptId::try_from(
std::borrow::Cow::Owned(id.to_owned()),
)
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Error while getting GlobalAttemptId")?;
let payment_attempt = db
.find_payment_attempt_by_id(merchant_key_store, &global_attempt_id, storage_scheme)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
let payment_intent = db
.find_payment_intent_by_id(
&payment_attempt.payment_id,
merchant_key_store,
storage_scheme,
)
.await
.to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
(payment_intent, payment_attempt)
}
api_models::payments::PaymentIdType::PreprocessingId(ref _id) => todo!(),
};
// We need the address here to send it in the response
// In case we need to send an outgoing webhook, we might have to send the billing address and shipping address
let payment_address = hyperswitch_domain_models::payment_address::PaymentAddress::new(
payment_intent
.shipping_address
.clone()
.map(|address| address.into_inner()),
payment_intent
.billing_address
.clone()
.map(|address| address.into_inner()),
payment_attempt
.payment_method_billing_address
.clone()
.map(|address| address.into_inner()),
Some(true),
);
Ok(payments::operations::GetTrackerResponse {
payment_data: PaymentStatusData {
flow: PhantomData,
payment_intent,
payment_attempt,
attempts: None,
should_sync_with_connector: true,
payment_address,
merchant_connector_details: None,
},
})
}
#[inline]
async fn verify_webhook_source_verification_call(
connector: ConnectorEnum,
state: &SessionState,
platform: &domain::Platform,
merchant_connector_account: domain::MerchantConnectorAccount,
connector_name: &str,
request_details: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<bool, errors::ConnectorError> {
let connector_data = ConnectorData::get_connector_by_name(
&state.conf.connectors,
connector_name,
GetToken::Connector,
None,
)
.change_context(errors::ConnectorError::WebhookSourceVerificationFailed)
.attach_printable("invalid connector name received in payment attempt")?;
let connector_integration: services::BoxedWebhookSourceVerificationConnectorIntegrationInterface<
hyperswitch_domain_models::router_flow_types::VerifyWebhookSource,
VerifyWebhookSourceRequestData,
VerifyWebhookSourceResponseData,
> = connector_data.connector.get_connector_integration();
let connector_webhook_secrets = connector
.get_webhook_source_verification_merchant_secret(
platform.get_processor().get_account().get_id(),
connector_name,
merchant_connector_account.connector_webhook_details.clone(),
)
.await
.change_context(errors::ConnectorError::WebhookSourceVerificationFailed)?;
let router_data = construct_webhook_router_data(
state,
connector_name,
merchant_connector_account,
platform,
&connector_webhook_secrets,
request_details,
)
.await
.change_context(errors::ConnectorError::WebhookSourceVerificationFailed)
.attach_printable("Failed while constructing webhook router data")?;
let response = services::execute_connector_processing_step(
state,
connector_integration,
&router_data,
payments::CallConnectorAction::Trigger,
None,
None,
)
.await?;
let verification_result = response
.response
.map(|response| response.verify_webhook_status);
match verification_result {
Ok(VerifyWebhookStatus::SourceVerified) => Ok(true),
_ => Ok(false),
}
}
fn get_connector_by_connector_name(
state: &SessionState,
connector_name: &str,
merchant_connector_id: Option<common_utils::id_type::MerchantConnectorAccountId>,
) -> CustomResult<(ConnectorEnum, String), errors::ApiErrorResponse> {
let authentication_connector =
api_models::enums::convert_authentication_connector(connector_name);
#[cfg(feature = "frm")]
{
let frm_connector = api_models::enums::convert_frm_connector(connector_name);
if frm_connector.is_some() {
let frm_connector_data =
api::FraudCheckConnectorData::get_connector_by_name(connector_name)?;
return Ok((
frm_connector_data.connector,
frm_connector_data.connector_name.to_string(),
));
}
}
let (connector, connector_name) = if authentication_connector.is_some() {
let authentication_connector_data =
api::AuthenticationConnectorData::get_connector_by_name(connector_name)?;
(
authentication_connector_data.connector,
authentication_connector_data.connector_name.to_string(),
)
} else {
let connector_data = ConnectorData::get_connector_by_name(
&state.conf.connectors,
connector_name,
GetToken::Connector,
merchant_connector_id,
)
.change_context(errors::ApiErrorResponse::InvalidRequestData {
message: "invalid connector name received".to_string(),
})
.attach_printable("Failed construction of ConnectorData")?;
(
connector_data.connector,
connector_data.connector_name.to_string(),
)
};
Ok((connector, connector_name))
}
/// This function fetches the merchant connector account and connector details
async fn fetch_mca_and_connector(
state: &SessionState,
connector_id: &common_utils::id_type::MerchantConnectorAccountId,
key_store: &domain::MerchantKeyStore,
) -> CustomResult<(domain::MerchantConnectorAccount, ConnectorEnum, String), errors::ApiErrorResponse>
{
let db = &state.store;
let mca = db
.find_merchant_connector_account_by_id(connector_id, key_store)
.await
.to_not_found_response(errors::ApiErrorResponse::MerchantConnectorAccountNotFound {
id: connector_id.get_string_repr().to_owned(),
})
.attach_printable("error while fetching merchant_connector_account from connector_id")?;
let (connector, connector_name) = get_connector_by_connector_name(
state,
&mca.connector_name.to_string(),
Some(mca.get_id()),
)?;
Ok((mca, connector, connector_name))
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/webhooks/outgoing.rs | crates/router/src/core/webhooks/outgoing.rs | use std::collections::HashMap;
use api_models::{
webhook_events::{OutgoingWebhookRequestContent, OutgoingWebhookResponseContent},
webhooks,
};
use common_utils::{
ext_traits::{Encode, StringExt},
request::RequestContent,
type_name,
types::keymanager::Identifier,
};
use diesel_models::process_tracker::business_status;
use error_stack::{report, ResultExt};
use hyperswitch_domain_models::type_encryption::{crypto_operation, CryptoOperation};
use hyperswitch_interfaces::consts;
use masking::{ExposeInterface, Mask, PeekInterface, Secret};
use router_env::{
instrument,
tracing::{self, Instrument},
};
use super::{types, utils, MERCHANT_ID};
#[cfg(feature = "stripe")]
use crate::compatibility::stripe::webhooks as stripe_webhooks;
use crate::{
core::{
errors::{self, CustomResult},
metrics,
},
db::StorageInterface,
events::outgoing_webhook_logs::{
OutgoingWebhookEvent, OutgoingWebhookEventContent, OutgoingWebhookEventMetric,
},
logger,
routes::{app::SessionStateInfo, SessionState},
services,
types::{
api,
domain::{self},
storage::{self, enums},
transformers::ForeignFrom,
},
utils::{OptionExt, ValueExt},
workflows::outgoing_webhook_retry,
};
#[allow(clippy::too_many_arguments)]
#[instrument(skip_all)]
pub(crate) async fn create_event_and_trigger_outgoing_webhook(
state: SessionState,
platform: domain::Platform,
business_profile: domain::Profile,
event_type: enums::EventType,
event_class: enums::EventClass,
primary_object_id: String,
primary_object_type: enums::EventObjectType,
content: api::OutgoingWebhookContent,
primary_object_created_at: Option<time::PrimitiveDateTime>,
) -> CustomResult<(), errors::ApiErrorResponse> {
let delivery_attempt = enums::WebhookDeliveryAttempt::InitialAttempt;
let idempotent_event_id =
utils::get_idempotent_event_id(&primary_object_id, event_type, delivery_attempt)
.change_context(errors::ApiErrorResponse::WebhookProcessingFailure)
.attach_printable("Failed to generate idempotent event ID")?;
let webhook_url_result = get_webhook_url_from_business_profile(&business_profile);
if !state.conf.webhooks.outgoing_enabled
|| webhook_url_result.is_err()
|| webhook_url_result.as_ref().is_ok_and(String::is_empty)
{
logger::debug!(
business_profile_id=?business_profile.get_id(),
%idempotent_event_id,
"Outgoing webhooks are disabled in application configuration, or merchant webhook URL \
could not be obtained; skipping outgoing webhooks for event"
);
return Ok(());
}
let event_id = utils::generate_event_id();
let merchant_id = business_profile.merchant_id.clone();
let now = common_utils::date_time::now();
let outgoing_webhook = api::OutgoingWebhook {
merchant_id: merchant_id.clone(),
event_id: event_id.clone(),
event_type,
content: content.clone(),
timestamp: now,
};
let request_content =
get_outgoing_webhook_request(&platform, outgoing_webhook, &business_profile)
.change_context(errors::ApiErrorResponse::WebhookProcessingFailure)
.attach_printable("Failed to construct outgoing webhook request content")?;
let event_metadata = storage::EventMetadata::foreign_from(&content);
let key_manager_state = &(&state).into();
let new_event = domain::Event {
event_id: event_id.clone(),
event_type,
event_class,
is_webhook_notified: false,
primary_object_id,
primary_object_type,
created_at: now,
merchant_id: Some(business_profile.merchant_id.clone()),
business_profile_id: Some(business_profile.get_id().to_owned()),
primary_object_created_at,
idempotent_event_id: Some(idempotent_event_id.clone()),
initial_attempt_id: Some(event_id.clone()),
request: Some(
crypto_operation(
key_manager_state,
type_name!(domain::Event),
CryptoOperation::Encrypt(
request_content
.encode_to_string_of_json()
.change_context(errors::ApiErrorResponse::WebhookProcessingFailure)
.attach_printable("Failed to encode outgoing webhook request content")
.map(Secret::new)?,
),
Identifier::Merchant(platform.get_processor().get_key_store().merchant_id.clone()),
platform
.get_processor()
.get_key_store()
.key
.get_inner()
.peek(),
)
.await
.and_then(|val| val.try_into_operation())
.change_context(errors::ApiErrorResponse::WebhookProcessingFailure)
.attach_printable("Failed to encrypt outgoing webhook request content")?,
),
response: None,
delivery_attempt: Some(delivery_attempt),
metadata: Some(event_metadata),
is_overall_delivery_successful: Some(false),
};
let lock_value = utils::perform_redis_lock(
&state,
&idempotent_event_id,
platform.get_processor().get_account().get_id().to_owned(),
)
.await?;
if lock_value.is_none() {
return Ok(());
}
if (state
.store
.find_event_by_merchant_id_idempotent_event_id(
&merchant_id,
&idempotent_event_id,
platform.get_processor().get_key_store(),
)
.await)
.is_ok()
{
logger::debug!(
"Event with idempotent ID `{idempotent_event_id}` already exists in the database"
);
utils::free_redis_lock(
&state,
&idempotent_event_id,
platform.get_processor().get_account().get_id().to_owned(),
lock_value,
)
.await?;
return Ok(());
}
let event_insert_result = state
.store
.insert_event(new_event, platform.get_processor().get_key_store())
.await;
let event = match event_insert_result {
Ok(event) => Ok(event),
Err(error) => {
logger::error!(event_insertion_failure=?error);
Err(error
.change_context(errors::ApiErrorResponse::WebhookProcessingFailure)
.attach_printable("Failed to insert event in events table"))
}
}?;
utils::free_redis_lock(
&state,
&idempotent_event_id,
platform.get_processor().get_account().get_id().to_owned(),
lock_value,
)
.await?;
let process_tracker = add_outgoing_webhook_retry_task_to_process_tracker(
&*state.store,
&business_profile,
&event,
state.conf.application_source,
)
.await
.inspect_err(|error| {
logger::error!(
?error,
"Failed to add outgoing webhook retry task to process tracker"
);
})
.ok();
let cloned_key_store = platform.get_processor().get_key_store().clone();
// Using a tokio spawn here and not arbiter because not all caller of this function
// may have an actix arbiter
tokio::spawn(
async move {
Box::pin(trigger_webhook_and_raise_event(
state,
business_profile,
&cloned_key_store,
event,
request_content,
delivery_attempt,
Some(content),
process_tracker,
))
.await;
}
.in_current_span(),
);
Ok(())
}
#[allow(clippy::too_many_arguments)]
#[instrument(skip_all)]
pub(crate) async fn trigger_webhook_and_raise_event(
state: SessionState,
business_profile: domain::Profile,
merchant_key_store: &domain::MerchantKeyStore,
event: domain::Event,
request_content: OutgoingWebhookRequestContent,
delivery_attempt: enums::WebhookDeliveryAttempt,
content: Option<api::OutgoingWebhookContent>,
process_tracker: Option<storage::ProcessTracker>,
) {
logger::debug!(
event_id=%event.event_id,
idempotent_event_id=?event.idempotent_event_id,
initial_attempt_id=?event.initial_attempt_id,
"Attempting to send webhook"
);
let merchant_id = business_profile.merchant_id.clone();
let trigger_webhook_result = trigger_webhook_to_merchant(
state.clone(),
business_profile,
merchant_key_store,
event.clone(),
request_content,
delivery_attempt,
process_tracker,
)
.await;
let _ = raise_webhooks_analytics_event(
state,
trigger_webhook_result,
content,
merchant_id,
event,
merchant_key_store,
)
.await;
}
async fn trigger_webhook_to_merchant(
state: SessionState,
business_profile: domain::Profile,
merchant_key_store: &domain::MerchantKeyStore,
event: domain::Event,
request_content: OutgoingWebhookRequestContent,
delivery_attempt: enums::WebhookDeliveryAttempt,
process_tracker: Option<storage::ProcessTracker>,
) -> CustomResult<(), errors::WebhooksFlowError> {
let webhook_url = match (
get_webhook_url_from_business_profile(&business_profile),
process_tracker.clone(),
) {
(Ok(webhook_url), _) => Ok(webhook_url),
(Err(error), Some(process_tracker)) => {
if !error
.current_context()
.is_webhook_delivery_retryable_error()
{
logger::debug!("Failed to obtain merchant webhook URL, aborting retries");
state
.store
.as_scheduler()
.finish_process_with_business_status(process_tracker, business_status::FAILURE)
.await
.change_context(
errors::WebhooksFlowError::OutgoingWebhookProcessTrackerTaskUpdateFailed,
)?;
}
Err(error)
}
(Err(error), None) => Err(error),
}?;
let event_id = event.event_id;
let headers = request_content
.headers
.into_iter()
.map(|(name, value)| (name, value.into_masked()))
.collect();
let request = services::RequestBuilder::new()
.method(services::Method::Post)
.url(&webhook_url)
.attach_default_headers()
.headers(headers)
.set_body(RequestContent::RawBytes(
request_content.body.expose().into_bytes(),
))
.build();
let response = state
.api_client
.send_request(&state, request, None, false)
.await;
metrics::WEBHOOK_OUTGOING_COUNT.add(
1,
router_env::metric_attributes!((MERCHANT_ID, business_profile.merchant_id.clone())),
);
logger::debug!(outgoing_webhook_response=?response);
match delivery_attempt {
enums::WebhookDeliveryAttempt::InitialAttempt => match response {
Err(client_error) => {
api_client_error_handler(
state.clone(),
merchant_key_store.clone(),
&business_profile.merchant_id,
&event_id,
client_error,
delivery_attempt,
ScheduleWebhookRetry::NoSchedule,
)
.await?
}
Ok(response) => {
let status_code = response.status();
let updated_event = update_event_in_storage(
state.clone(),
merchant_key_store.clone(),
&business_profile.merchant_id,
&event_id,
response,
)
.await?;
if status_code.is_success() {
update_overall_delivery_status_in_storage(
state.clone(),
merchant_key_store.clone(),
&business_profile.merchant_id,
updated_event,
)
.await?;
success_response_handler(
state.clone(),
&business_profile.merchant_id,
process_tracker,
business_status::INITIAL_DELIVERY_ATTEMPT_SUCCESSFUL,
)
.await?;
} else {
error_response_handler(
state.clone(),
&business_profile.merchant_id,
delivery_attempt,
status_code.as_u16(),
"Ignoring error when sending webhook to merchant",
ScheduleWebhookRetry::NoSchedule,
)
.await?;
}
}
},
enums::WebhookDeliveryAttempt::AutomaticRetry => {
let process_tracker = process_tracker
.get_required_value("process_tracker")
.change_context(errors::WebhooksFlowError::OutgoingWebhookRetrySchedulingFailed)
.attach_printable("`process_tracker` is unavailable in automatic retry flow")?;
match response {
Err(client_error) => {
api_client_error_handler(
state.clone(),
merchant_key_store.clone(),
&business_profile.merchant_id,
&event_id,
client_error,
delivery_attempt,
ScheduleWebhookRetry::WithProcessTracker(Box::new(process_tracker)),
)
.await?;
}
Ok(response) => {
let status_code = response.status();
let updated_event = update_event_in_storage(
state.clone(),
merchant_key_store.clone(),
&business_profile.merchant_id,
&event_id,
response,
)
.await?;
if status_code.is_success() {
update_overall_delivery_status_in_storage(
state.clone(),
merchant_key_store.clone(),
&business_profile.merchant_id,
updated_event,
)
.await?;
success_response_handler(
state.clone(),
&business_profile.merchant_id,
Some(process_tracker),
"COMPLETED_BY_PT",
)
.await?;
} else {
error_response_handler(
state.clone(),
&business_profile.merchant_id,
delivery_attempt,
status_code.as_u16(),
"An error occurred when sending webhook to merchant",
ScheduleWebhookRetry::WithProcessTracker(Box::new(process_tracker)),
)
.await?;
}
}
}
}
enums::WebhookDeliveryAttempt::ManualRetry => match response {
Err(client_error) => {
api_client_error_handler(
state.clone(),
merchant_key_store.clone(),
&business_profile.merchant_id,
&event_id,
client_error,
delivery_attempt,
ScheduleWebhookRetry::NoSchedule,
)
.await?
}
Ok(response) => {
let status_code = response.status();
let _updated_event = update_event_in_storage(
state.clone(),
merchant_key_store.clone(),
&business_profile.merchant_id,
&event_id,
response,
)
.await?;
if status_code.is_success() {
increment_webhook_outgoing_received_count(&business_profile.merchant_id);
} else {
error_response_handler(
state,
&business_profile.merchant_id,
delivery_attempt,
status_code.as_u16(),
"Ignoring error when sending webhook to merchant",
ScheduleWebhookRetry::NoSchedule,
)
.await?;
}
}
},
}
Ok(())
}
async fn raise_webhooks_analytics_event(
state: SessionState,
trigger_webhook_result: CustomResult<(), errors::WebhooksFlowError>,
content: Option<api::OutgoingWebhookContent>,
merchant_id: common_utils::id_type::MerchantId,
event: domain::Event,
merchant_key_store: &domain::MerchantKeyStore,
) {
let event_id = event.event_id;
let error = if let Err(error) = trigger_webhook_result {
logger::error!(?error, "Failed to send webhook to merchant");
serde_json::to_value(error.current_context())
.change_context(errors::ApiErrorResponse::WebhookProcessingFailure)
.inspect_err(|error| {
logger::error!(?error, "Failed to serialize outgoing webhook error as JSON");
})
.ok()
} else {
None
};
let outgoing_webhook_event_content = content
.as_ref()
.and_then(api::OutgoingWebhookContent::get_outgoing_webhook_event_content)
.or_else(|| get_outgoing_webhook_event_content_from_event_metadata(event.metadata));
// Fetch updated_event from db
let updated_event = state
.store
.find_event_by_merchant_id_event_id(&merchant_id, &event_id, merchant_key_store)
.await
.attach_printable_lazy(|| format!("event not found for id: {}", &event_id))
.map_err(|error| {
logger::error!(?error);
error
})
.ok();
// Get status_code from webhook response
let status_code = updated_event.and_then(|updated_event| {
let webhook_response: Option<OutgoingWebhookResponseContent> =
updated_event.response.and_then(|res| {
res.peek()
.parse_struct("OutgoingWebhookResponseContent")
.map_err(|error| {
logger::error!(?error, "Error deserializing webhook response");
error
})
.ok()
});
webhook_response.and_then(|res| res.status_code)
});
let webhook_event = OutgoingWebhookEvent::new(
state.tenant.tenant_id.clone(),
merchant_id,
event_id,
event.event_type,
outgoing_webhook_event_content,
error,
event.initial_attempt_id,
status_code,
event.delivery_attempt,
);
state.event_handler().log_event(&webhook_event);
}
pub(crate) async fn add_outgoing_webhook_retry_task_to_process_tracker(
db: &dyn StorageInterface,
business_profile: &domain::Profile,
event: &domain::Event,
application_source: common_enums::ApplicationSource,
) -> CustomResult<storage::ProcessTracker, errors::StorageError> {
let schedule_time = outgoing_webhook_retry::get_webhook_delivery_retry_schedule_time(
db,
&business_profile.merchant_id,
0,
)
.await
.ok_or(errors::StorageError::ValueNotFound(
"Process tracker schedule time".into(), // Can raise a better error here
))
.attach_printable("Failed to obtain initial process tracker schedule time")?;
let tracking_data = types::OutgoingWebhookTrackingData {
merchant_id: business_profile.merchant_id.clone(),
business_profile_id: business_profile.get_id().to_owned(),
event_type: event.event_type,
event_class: event.event_class,
primary_object_id: event.primary_object_id.clone(),
primary_object_type: event.primary_object_type,
initial_attempt_id: event.initial_attempt_id.clone(),
};
let runner = storage::ProcessTrackerRunner::OutgoingWebhookRetryWorkflow;
let task = "OUTGOING_WEBHOOK_RETRY";
let tag = ["OUTGOING_WEBHOOKS"];
let process_tracker_id = scheduler::utils::get_process_tracker_id(
runner,
task,
&event.event_id,
&business_profile.merchant_id,
);
let process_tracker_entry = storage::ProcessTrackerNew::new(
process_tracker_id,
task,
runner,
tag,
tracking_data,
None,
schedule_time,
common_types::consts::API_VERSION,
application_source,
)
.map_err(errors::StorageError::from)?;
let attributes = router_env::metric_attributes!(("flow", "OutgoingWebhookRetry"));
match db.insert_process(process_tracker_entry).await {
Ok(process_tracker) => {
crate::routes::metrics::TASKS_ADDED_COUNT.add(1, attributes);
Ok(process_tracker)
}
Err(error) => {
crate::routes::metrics::TASK_ADDITION_FAILURES_COUNT.add(1, attributes);
Err(error)
}
}
}
fn get_webhook_url_from_business_profile(
business_profile: &domain::Profile,
) -> CustomResult<String, errors::WebhooksFlowError> {
let webhook_details = business_profile
.webhook_details
.clone()
.get_required_value("webhook_details")
.change_context(errors::WebhooksFlowError::MerchantWebhookDetailsNotFound)?;
webhook_details
.webhook_url
.get_required_value("webhook_url")
.change_context(errors::WebhooksFlowError::MerchantWebhookUrlNotConfigured)
.map(ExposeInterface::expose)
}
pub(crate) fn get_outgoing_webhook_request(
platform: &domain::Platform,
outgoing_webhook: api::OutgoingWebhook,
business_profile: &domain::Profile,
) -> CustomResult<OutgoingWebhookRequestContent, errors::WebhooksFlowError> {
#[inline]
fn get_outgoing_webhook_request_inner<WebhookType: types::OutgoingWebhookType>(
outgoing_webhook: api::OutgoingWebhook,
business_profile: &domain::Profile,
) -> CustomResult<OutgoingWebhookRequestContent, errors::WebhooksFlowError> {
let mut headers = vec![
(
reqwest::header::CONTENT_TYPE.to_string(),
mime::APPLICATION_JSON.essence_str().into(),
),
(
reqwest::header::USER_AGENT.to_string(),
consts::USER_AGENT.to_string().into(),
),
];
let transformed_outgoing_webhook = WebhookType::from(outgoing_webhook);
let payment_response_hash_key = business_profile.payment_response_hash_key.clone();
let custom_headers = business_profile
.outgoing_webhook_custom_http_headers
.clone()
.map(|headers| {
headers
.into_inner()
.expose()
.parse_value::<HashMap<String, String>>("HashMap<String,String>")
.change_context(errors::WebhooksFlowError::OutgoingWebhookEncodingFailed)
.attach_printable("Failed to deserialize outgoing webhook custom HTTP headers")
})
.transpose()?;
if let Some(ref map) = custom_headers {
headers.extend(
map.iter()
.map(|(key, value)| (key.clone(), value.clone().into_masked())),
);
};
let outgoing_webhooks_signature = transformed_outgoing_webhook
.get_outgoing_webhooks_signature(payment_response_hash_key)?;
if let Some(signature) = outgoing_webhooks_signature.signature {
WebhookType::add_webhook_header(&mut headers, signature)
}
Ok(OutgoingWebhookRequestContent {
body: outgoing_webhooks_signature.payload,
headers: headers
.into_iter()
.map(|(name, value)| (name, Secret::new(value.into_inner())))
.collect(),
})
}
match platform
.get_processor()
.get_account()
.get_compatible_connector()
{
#[cfg(feature = "stripe")]
Some(api_models::enums::Connector::Stripe) => get_outgoing_webhook_request_inner::<
stripe_webhooks::StripeOutgoingWebhook,
>(outgoing_webhook, business_profile),
_ => get_outgoing_webhook_request_inner::<webhooks::OutgoingWebhook>(
outgoing_webhook,
business_profile,
),
}
}
#[derive(Debug)]
enum ScheduleWebhookRetry {
WithProcessTracker(Box<storage::ProcessTracker>),
NoSchedule,
}
async fn update_event_if_client_error(
state: SessionState,
merchant_key_store: domain::MerchantKeyStore,
merchant_id: &common_utils::id_type::MerchantId,
event_id: &str,
error_message: String,
) -> CustomResult<domain::Event, errors::WebhooksFlowError> {
let is_webhook_notified = false;
let key_manager_state = &(&state).into();
let response_to_store = OutgoingWebhookResponseContent {
body: None,
headers: None,
status_code: None,
error_message: Some(error_message),
};
let event_update = domain::EventUpdate::UpdateResponse {
is_webhook_notified,
response: Some(
crypto_operation(
key_manager_state,
type_name!(domain::Event),
CryptoOperation::Encrypt(
response_to_store
.encode_to_string_of_json()
.change_context(
errors::WebhooksFlowError::OutgoingWebhookResponseEncodingFailed,
)
.map(Secret::new)?,
),
Identifier::Merchant(merchant_key_store.merchant_id.clone()),
merchant_key_store.key.get_inner().peek(),
)
.await
.and_then(|val| val.try_into_operation())
.change_context(errors::WebhooksFlowError::WebhookEventUpdationFailed)
.attach_printable("Failed to encrypt outgoing webhook response content")?,
),
};
state
.store
.update_event_by_merchant_id_event_id(
merchant_id,
event_id,
event_update,
&merchant_key_store,
)
.await
.change_context(errors::WebhooksFlowError::WebhookEventUpdationFailed)
}
async fn api_client_error_handler(
state: SessionState,
merchant_key_store: domain::MerchantKeyStore,
merchant_id: &common_utils::id_type::MerchantId,
event_id: &str,
client_error: error_stack::Report<errors::ApiClientError>,
delivery_attempt: enums::WebhookDeliveryAttempt,
schedule_webhook_retry: ScheduleWebhookRetry,
) -> CustomResult<(), errors::WebhooksFlowError> {
// Not including detailed error message in response information since it contains too
// much of diagnostic information to be exposed to the merchant.
update_event_if_client_error(
state.clone(),
merchant_key_store,
merchant_id,
event_id,
"Unable to send request to merchant server".to_string(),
)
.await?;
let error = client_error.change_context(errors::WebhooksFlowError::CallToMerchantFailed);
logger::error!(
?error,
?delivery_attempt,
"An error occurred when sending webhook to merchant"
);
if let ScheduleWebhookRetry::WithProcessTracker(process_tracker) = schedule_webhook_retry {
// Schedule a retry attempt for webhook delivery
outgoing_webhook_retry::retry_webhook_delivery_task(
&*state.store,
merchant_id,
*process_tracker,
)
.await
.change_context(errors::WebhooksFlowError::OutgoingWebhookRetrySchedulingFailed)?;
}
Err(error)
}
async fn update_event_in_storage(
state: SessionState,
merchant_key_store: domain::MerchantKeyStore,
merchant_id: &common_utils::id_type::MerchantId,
event_id: &str,
response: reqwest::Response,
) -> CustomResult<domain::Event, errors::WebhooksFlowError> {
let status_code = response.status();
let is_webhook_notified = status_code.is_success();
let key_manager_state = &(&state).into();
let response_headers = response
.headers()
.iter()
.map(|(name, value)| {
(
name.as_str().to_owned(),
value
.to_str()
.map(|s| Secret::from(String::from(s)))
.unwrap_or_else(|error| {
logger::warn!(
"Response header {} contains non-UTF-8 characters: {error:?}",
name.as_str()
);
Secret::from(String::from("Non-UTF-8 header value"))
}),
)
})
.collect::<Vec<_>>();
let response_body = response
.text()
.await
.map(Secret::from)
.unwrap_or_else(|error| {
logger::warn!("Response contains non-UTF-8 characters: {error:?}");
Secret::from(String::from("Non-UTF-8 response body"))
});
let response_to_store = OutgoingWebhookResponseContent {
body: Some(response_body),
headers: Some(response_headers),
status_code: Some(status_code.as_u16()),
error_message: None,
};
let event_update = domain::EventUpdate::UpdateResponse {
is_webhook_notified,
response: Some(
crypto_operation(
key_manager_state,
type_name!(domain::Event),
CryptoOperation::Encrypt(
response_to_store
.encode_to_string_of_json()
.change_context(
errors::WebhooksFlowError::OutgoingWebhookResponseEncodingFailed,
)
.map(Secret::new)?,
),
Identifier::Merchant(merchant_key_store.merchant_id.clone()),
merchant_key_store.key.get_inner().peek(),
)
.await
.and_then(|val| val.try_into_operation())
.change_context(errors::WebhooksFlowError::WebhookEventUpdationFailed)
.attach_printable("Failed to encrypt outgoing webhook response content")?,
),
};
state
.store
.update_event_by_merchant_id_event_id(
merchant_id,
event_id,
event_update,
&merchant_key_store,
)
.await
.change_context(errors::WebhooksFlowError::WebhookEventUpdationFailed)
}
async fn update_overall_delivery_status_in_storage(
state: SessionState,
merchant_key_store: domain::MerchantKeyStore,
merchant_id: &common_utils::id_type::MerchantId,
updated_event: domain::Event,
) -> CustomResult<(), errors::WebhooksFlowError> {
let update_overall_delivery_status = domain::EventUpdate::OverallDeliveryStatusUpdate {
is_overall_delivery_successful: true,
};
let initial_attempt_id = updated_event.initial_attempt_id.as_ref();
let delivery_attempt = updated_event.delivery_attempt;
if let Some((
initial_attempt_id,
enums::WebhookDeliveryAttempt::InitialAttempt
| enums::WebhookDeliveryAttempt::AutomaticRetry,
)) = initial_attempt_id.zip(delivery_attempt)
{
state
.store
.update_event_by_merchant_id_event_id(
merchant_id,
initial_attempt_id.as_str(),
update_overall_delivery_status,
&merchant_key_store,
)
.await
.change_context(errors::WebhooksFlowError::WebhookEventUpdationFailed)
.attach_printable("Failed to update initial delivery attempt")?;
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | true |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/webhooks/incoming.rs | crates/router/src/core/webhooks/incoming.rs | use std::{str::FromStr, time::Instant};
use actix_web::FromRequest;
#[cfg(feature = "payouts")]
use api_models::payouts as payout_models;
use api_models::{
enums::Connector,
webhooks::{self, WebhookResponseTracker},
};
pub use common_enums::{connector_enums::InvoiceStatus, enums::ProcessTrackerRunner};
use common_utils::{
errors::ReportSwitchExt,
events::ApiEventsType,
ext_traits::{AsyncExt, ByteSliceExt},
types::{AmountConvertor, StringMinorUnitForConnector},
};
use diesel_models::{refund as diesel_refund, ConnectorMandateReferenceId};
use error_stack::{report, ResultExt};
#[cfg(feature = "payouts")]
use hyperswitch_domain_models::payouts::payouts::PayoutsUpdate;
use hyperswitch_domain_models::{
mandates::CommonMandateReference,
merchant_key_store::MerchantKeyStore,
payments::{payment_attempt::PaymentAttempt, HeaderPayload},
router_request_types::VerifyWebhookSourceRequestData,
router_response_types::{VerifyWebhookSourceResponseData, VerifyWebhookStatus},
};
use hyperswitch_interfaces::webhooks::{IncomingWebhookFlowError, IncomingWebhookRequestDetails};
use masking::{ExposeInterface, PeekInterface};
use router_env::{instrument, tracing, RequestId};
use unified_connector_service_client::payments as payments_grpc;
use super::{types, utils, MERCHANT_ID};
use crate::{
consts,
core::{
api_locking,
errors::{self, ConnectorErrorExt, CustomResult, RouterResponse, StorageErrorExt},
metrics, payment_methods,
payment_methods::cards,
payments::{self, tokenization},
refunds, relay, unified_connector_service, utils as core_utils,
webhooks::{network_tokenization_incoming, utils::construct_webhook_router_data},
},
db::StorageInterface,
events::api_logs::ApiEvent,
logger,
routes::{
app::{ReqState, SessionStateInfo},
lock_utils, SessionState,
},
services::{
self, authentication as auth, connector_integration_interface::ConnectorEnum,
ConnectorValidation,
},
types::{
api::{
self, mandates::MandateResponseExt, ConnectorCommon, ConnectorData, GetToken,
IncomingWebhook,
},
domain,
storage::{self, enums},
transformers::{ForeignFrom, ForeignInto, ForeignTryFrom},
},
utils::{self as helper_utils, ext_traits::OptionExt, generate_id},
};
#[cfg(feature = "payouts")]
use crate::{core::payouts, types::storage::PayoutAttemptUpdate};
#[allow(clippy::too_many_arguments)]
pub async fn incoming_webhooks_wrapper<W: types::OutgoingWebhookType>(
flow: &impl router_env::types::FlowMetric,
state: SessionState,
req_state: ReqState,
req: &actix_web::HttpRequest,
platform: domain::Platform,
connector_name_or_mca_id: &str,
body: actix_web::web::Bytes,
is_relay_webhook: bool,
) -> RouterResponse<serde_json::Value> {
let start_instant = Instant::now();
let (application_response, webhooks_response_tracker, serialized_req) =
Box::pin(incoming_webhooks_core::<W>(
state.clone(),
req_state,
req,
platform.clone(),
connector_name_or_mca_id,
body.clone(),
is_relay_webhook,
))
.await?;
logger::info!(incoming_webhook_payload = ?serialized_req);
let request_duration = Instant::now()
.saturating_duration_since(start_instant)
.as_millis();
let request_id = RequestId::extract(req)
.await
.attach_printable("Unable to extract request id from request")
.change_context(errors::ApiErrorResponse::InternalServerError)?;
let auth_type = auth::AuthenticationType::WebhookAuth {
merchant_id: platform.get_processor().get_account().get_id().clone(),
};
let status_code = 200;
let api_event = ApiEventsType::Webhooks {
connector: connector_name_or_mca_id.to_string(),
payment_id: webhooks_response_tracker.get_payment_id(),
refund_id: webhooks_response_tracker.get_refund_id(),
};
let response_value = serde_json::to_value(&webhooks_response_tracker)
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Could not convert webhook effect to string")?;
let infra = state.infra_components.clone();
let api_event = ApiEvent::new(
state.tenant.tenant_id.clone(),
Some(platform.get_processor().get_account().get_id().clone()),
flow,
&request_id,
request_duration,
status_code,
serialized_req,
Some(response_value),
None,
auth_type,
None,
api_event,
req,
req.method(),
infra,
);
state.event_handler().log_event(&api_event);
Ok(application_response)
}
#[cfg(feature = "v1")]
pub async fn network_token_incoming_webhooks_wrapper<W: types::OutgoingWebhookType>(
flow: &impl router_env::types::FlowMetric,
state: SessionState,
req: &actix_web::HttpRequest,
body: actix_web::web::Bytes,
) -> RouterResponse<serde_json::Value> {
let start_instant = Instant::now();
let request_details: IncomingWebhookRequestDetails<'_> = IncomingWebhookRequestDetails {
method: req.method().clone(),
uri: req.uri().clone(),
headers: req.headers(),
query_params: req.query_string().to_string(),
body: &body,
};
let (application_response, webhooks_response_tracker, serialized_req, merchant_id) = Box::pin(
network_token_incoming_webhooks_core::<W>(&state, request_details),
)
.await?;
logger::info!(incoming_webhook_payload = ?serialized_req);
let request_duration = Instant::now()
.saturating_duration_since(start_instant)
.as_millis();
let request_id = RequestId::extract(req)
.await
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Unable to extract request id from request")?;
let auth_type = auth::AuthenticationType::NoAuth;
let status_code = 200;
let api_event = ApiEventsType::NetworkTokenWebhook {
payment_method_id: webhooks_response_tracker.get_payment_method_id(),
};
let response_value = serde_json::to_value(&webhooks_response_tracker)
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Could not convert webhook effect to string")?;
let infra = state.infra_components.clone();
let api_event = ApiEvent::new(
state.tenant.tenant_id.clone(),
Some(merchant_id),
flow,
&request_id,
request_duration,
status_code,
serialized_req,
Some(response_value),
None,
auth_type,
None,
api_event,
req,
req.method(),
infra,
);
state.event_handler().log_event(&api_event);
Ok(application_response)
}
#[allow(clippy::too_many_arguments)]
#[instrument(skip_all)]
async fn incoming_webhooks_core<W: types::OutgoingWebhookType>(
state: SessionState,
req_state: ReqState,
req: &actix_web::HttpRequest,
platform: domain::Platform,
connector_name_or_mca_id: &str,
body: actix_web::web::Bytes,
is_relay_webhook: bool,
) -> errors::RouterResult<(
services::ApplicationResponse<serde_json::Value>,
WebhookResponseTracker,
serde_json::Value,
)> {
// Initial setup and metrics
metrics::WEBHOOK_INCOMING_COUNT.add(
1,
router_env::metric_attributes!((
MERCHANT_ID,
platform.get_processor().get_account().get_id().clone()
)),
);
let request_details = IncomingWebhookRequestDetails {
method: req.method().clone(),
uri: req.uri().clone(),
headers: req.headers(),
query_params: req.query_string().to_string(),
body: &body,
};
// Fetch the merchant connector account to get the webhooks source secret
let (merchant_connector_account, connector, connector_name) =
fetch_optional_mca_and_connector(&state, &platform, connector_name_or_mca_id).await?;
// Determine webhook processing path (Direct vs UCS vs Shadow UCS) and handle event type extraction
let execution_path =
unified_connector_service::should_call_unified_connector_service_for_webhooks(
&state,
&platform,
&connector_name,
)
.await?;
let webhook_processing_result = match execution_path {
common_enums::ExecutionPath::UnifiedConnectorService => {
logger::info!(
connector = connector_name,
"Using Unified Connector Service for webhook processing",
);
process_ucs_webhook_transform(
&state,
&platform,
&connector_name,
&body,
&request_details,
merchant_connector_account.as_ref(),
)
.await
}
common_enums::ExecutionPath::ShadowUnifiedConnectorService => {
logger::info!(
connector = connector_name,
"Using Shadow Unified Connector Service for webhook processing",
);
process_shadow_ucs_webhook_transform(
&state,
&platform,
&connector,
&connector_name,
&body,
&request_details,
merchant_connector_account.as_ref(),
)
.await
}
common_enums::ExecutionPath::Direct => {
logger::info!(
connector = connector_name,
"Using Direct connector processing for webhook",
);
// DIRECT PATH: Need to decode body first
let decoded_body = connector
.decode_webhook_body(
&request_details,
platform.get_processor().get_account().get_id(),
merchant_connector_account
.clone()
.and_then(|mca| mca.connector_webhook_details.clone()),
&connector_name,
)
.await
.switch()
.attach_printable("There was an error in incoming webhook body decoding")?;
process_non_ucs_webhook(
&state,
&platform,
&connector,
&connector_name,
decoded_body.into(),
&request_details,
)
.await
}
};
let mut webhook_processing_result = match webhook_processing_result {
Ok(result) => result,
Err(error) => {
let error_result = handle_incoming_webhook_error(
error,
&connector,
connector_name.as_str(),
&request_details,
platform.get_processor().get_account().get_id(),
);
match error_result {
Ok((response, webhook_tracker, serialized_request)) => {
return Ok((response, webhook_tracker, serialized_request));
}
Err(e) => return Err(e),
}
}
};
// if it is a setup webhook event, return ok status
if webhook_processing_result.event_type == webhooks::IncomingWebhookEvent::SetupWebhook {
return Ok((
services::ApplicationResponse::StatusOk,
WebhookResponseTracker::NoEffect,
serde_json::Value::default(),
));
}
// Update request_details with the appropriate body (decoded for non-UCS, raw for UCS)
let final_request_details = match &webhook_processing_result.decoded_body {
Some(decoded_body) => &IncomingWebhookRequestDetails {
method: request_details.method.clone(),
uri: request_details.uri.clone(),
headers: request_details.headers,
query_params: request_details.query_params.clone(),
body: decoded_body,
},
None => &request_details, // Use original request details for UCS
};
logger::info!(event_type=?webhook_processing_result.event_type);
// Check if webhook should be processed further
let is_webhook_event_supported = !matches!(
webhook_processing_result.event_type,
webhooks::IncomingWebhookEvent::EventNotSupported
);
let is_webhook_event_enabled = !utils::is_webhook_event_disabled(
&*state.clone().store,
connector_name.as_str(),
platform.get_processor().get_account().get_id(),
&webhook_processing_result.event_type,
)
.await;
let flow_type: api::WebhookFlow = webhook_processing_result.event_type.into();
let process_webhook_further = is_webhook_event_enabled
&& is_webhook_event_supported
&& !matches!(flow_type, api::WebhookFlow::ReturnResponse);
logger::info!(process_webhook=?process_webhook_further);
let mut event_object: Box<dyn masking::ErasedMaskSerialize> = Box::new(serde_json::Value::Null);
let webhook_effect = match process_webhook_further {
true => {
let business_logic_result = process_webhook_business_logic(
&state,
req_state,
&platform,
&connector,
&connector_name,
webhook_processing_result.event_type,
webhook_processing_result.source_verified,
&webhook_processing_result.transform_data,
&mut webhook_processing_result.shadow_ucs_data,
final_request_details,
is_relay_webhook,
)
.await;
match business_logic_result {
Ok(response) => {
// Extract event object for serialization
event_object = extract_webhook_event_object(
&webhook_processing_result.transform_data,
&connector,
final_request_details,
)?;
response
}
Err(error) => {
let error_result = handle_incoming_webhook_error(
error,
&connector,
connector_name.as_str(),
final_request_details,
platform.get_processor().get_account().get_id(),
);
match error_result {
Ok((_, webhook_tracker, _)) => webhook_tracker,
Err(e) => return Err(e),
}
}
}
}
false => {
metrics::WEBHOOK_INCOMING_FILTERED_COUNT.add(
1,
router_env::metric_attributes!((
MERCHANT_ID,
platform.get_processor().get_account().get_id().clone()
)),
);
WebhookResponseTracker::NoEffect
}
};
// Generate response
let response = connector
.get_webhook_api_response(final_request_details, None)
.switch()
.attach_printable("Could not get incoming webhook api response from connector")?;
let serialized_request = event_object
.masked_serialize()
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Could not convert webhook effect to string")?;
Ok((response, webhook_effect, serialized_request))
}
/// Process UCS webhook transformation using the high-level UCS abstraction
async fn process_ucs_webhook_transform<'a>(
state: &'a SessionState,
platform: &'a domain::Platform,
connector_name: &'a str,
body: &'a actix_web::web::Bytes,
request_details: &'a IncomingWebhookRequestDetails<'a>,
merchant_connector_account: Option<&'a domain::MerchantConnectorAccount>,
) -> errors::RouterResult<WebhookProcessingResult<'a>> {
// Use the new UCS abstraction which provides clean separation
let (event_type, source_verified, transform_data) =
unified_connector_service::call_unified_connector_service_for_webhook(
state,
platform,
connector_name,
body,
request_details,
merchant_connector_account,
)
.await?;
Ok(WebhookProcessingResult {
event_type,
source_verified,
transform_data: Some(Box::new(transform_data)),
decoded_body: None, // UCS path uses raw body
shadow_ucs_data: None,
})
}
/// Shadow UCS data container
#[allow(dead_code)]
pub struct ShadowUcsData<'a> {
ucs_source_verified: bool,
ucs_event_type: webhooks::IncomingWebhookEvent,
ucs_transform_data: Box<unified_connector_service::WebhookTransformData>,
request_details: &'a IncomingWebhookRequestDetails<'a>,
webhook_details: Option<api::IncomingWebhookDetails>,
}
/// Result type for webhook processing path determination
pub struct WebhookProcessingResult<'a> {
event_type: webhooks::IncomingWebhookEvent,
source_verified: bool,
transform_data: Option<Box<unified_connector_service::WebhookTransformData>>,
decoded_body: Option<actix_web::web::Bytes>,
shadow_ucs_data: Option<ShadowUcsData<'a>>,
}
/// Process shadow UCS webhook transformation with dual execution (UCS + Direct)
async fn process_shadow_ucs_webhook_transform<'a>(
state: &'a SessionState,
platform: &'a domain::Platform,
connector: &'a ConnectorEnum,
connector_name: &'a str,
body: &'a actix_web::web::Bytes,
request_details: &'a IncomingWebhookRequestDetails<'a>,
merchant_connector_account: Option<&'a domain::MerchantConnectorAccount>,
) -> errors::RouterResult<WebhookProcessingResult<'a>> {
// Execute UCS path
let ucs_result = unified_connector_service::call_unified_connector_service_for_webhook(
state,
platform,
connector_name,
body,
request_details,
merchant_connector_account,
)
.await;
// Execute Direct path for comparison
let direct_result = async {
// Decode body for direct processing
let decoded_body = connector
.decode_webhook_body(
request_details,
platform.get_processor().get_account().get_id(),
merchant_connector_account.and_then(|mca| mca.connector_webhook_details.clone()),
connector_name,
)
.await
.switch()
.attach_printable(
"There was an error in incoming webhook body decoding for shadow processing",
)?;
// Reuse existing process_non_ucs_webhook function
process_non_ucs_webhook(
state,
platform,
connector,
connector_name,
decoded_body.into(),
request_details,
)
.await
}
.await;
// Handle results and comparison
match (ucs_result, direct_result) {
(
Ok((ucs_event_type, ucs_source_verified, ucs_transform_data)),
Ok(mut direct_processing_result),
) => {
// Log both calls succeeded
logger::info!(
connector = connector_name,
merchant_id = ?platform.get_processor().get_account().get_id(),
"Shadow UCS: Both UCS and Direct calls succeeded"
);
// Create ShadowUcsData with UCS results
let shadow_ucs_data = ShadowUcsData {
ucs_source_verified,
ucs_event_type,
ucs_transform_data: Box::new(ucs_transform_data),
request_details,
webhook_details: None,
};
// Return Direct result as primary with UCS data in shadow_ucs_data
direct_processing_result.shadow_ucs_data = Some(shadow_ucs_data);
Ok(direct_processing_result)
}
(Ok((_, _, _)), Err(direct_error)) => {
// Log UCS call succeeded, direct call failed
logger::info!(
connector = connector_name,
merchant_id = ?platform.get_processor().get_account().get_id(),
direct_error = ?direct_error,
"Shadow UCS: UCS call succeeded, Direct call failed"
);
// Return direct_result error as required
Err(direct_error)
}
(Err(ucs_error), Ok(direct_processing_result)) => {
// Log the UCS error and direct result succeeded
logger::info!(
connector = connector_name,
merchant_id = ?platform.get_processor().get_account().get_id(),
ucs_error = ?ucs_error,
"Shadow UCS: UCS call failed, Direct call succeeded"
);
// In shadow mode, if UCS fails, fall back to Direct result
Ok(direct_processing_result)
}
(Err(ucs_error), Err(direct_error)) => {
// Log both the errors and both call failed
logger::error!(
connector = connector_name,
merchant_id = ?platform.get_processor().get_account().get_id(),
ucs_error = ?ucs_error,
direct_error = ?direct_error,
"Shadow UCS: Both UCS and Direct calls failed"
);
// Return direct_result error as required
Err(direct_error)
}
}
}
/// Process non-UCS webhook using traditional connector processing
async fn process_non_ucs_webhook<'a>(
state: &'a SessionState,
platform: &'a domain::Platform,
connector: &'a ConnectorEnum,
connector_name: &'a str,
decoded_body: actix_web::web::Bytes,
request_details: &'a IncomingWebhookRequestDetails<'a>,
) -> errors::RouterResult<WebhookProcessingResult<'a>> {
// Create request_details with decoded body for connector processing
let updated_request_details = IncomingWebhookRequestDetails {
method: request_details.method.clone(),
uri: request_details.uri.clone(),
headers: request_details.headers,
query_params: request_details.query_params.clone(),
body: &decoded_body,
};
match connector
.get_webhook_event_type(&updated_request_details)
.allow_webhook_event_type_not_found(
state
.clone()
.conf
.webhooks
.ignore_error
.event_type
.unwrap_or(true),
)
.switch()
.attach_printable("Could not find event type in incoming webhook body")?
{
Some(event_type) => Ok(WebhookProcessingResult {
event_type,
source_verified: false,
transform_data: None,
decoded_body: Some(decoded_body),
shadow_ucs_data: None,
}),
None => {
metrics::WEBHOOK_EVENT_TYPE_IDENTIFICATION_FAILURE_COUNT.add(
1,
router_env::metric_attributes!(
(
MERCHANT_ID,
platform.get_processor().get_account().get_id().clone()
),
("connector", connector_name.to_string())
),
);
Err(errors::ApiErrorResponse::WebhookProcessingFailure)
.attach_printable("Failed to identify event type in incoming webhook body")
}
}
}
/// Extract resource object from UCS WebhookResponseContent
fn get_ucs_webhook_resource_object(
webhook_response_content: &payments_grpc::WebhookResponseContent,
) -> errors::RouterResult<Box<dyn masking::ErasedMaskSerialize>> {
let resource_object = match &webhook_response_content.content {
Some(payments_grpc::webhook_response_content::Content::IncompleteTransformation(
incomplete_transformation_response,
)) => {
// Deserialize resource object
serde_json::from_slice::<serde_json::Value>(
&incomplete_transformation_response.resource_object,
)
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed to deserialize resource object from UCS webhook response")?
}
_ => {
// Convert UCS webhook content to appropriate format
serde_json::to_value(webhook_response_content)
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable("Failed to serialize UCS webhook content")?
}
};
Ok(Box::new(resource_object))
}
/// Extract webhook event object based on transform data availability
fn extract_webhook_event_object(
webhook_transform_data: &Option<Box<unified_connector_service::WebhookTransformData>>,
connector: &ConnectorEnum,
request_details: &IncomingWebhookRequestDetails<'_>,
) -> errors::RouterResult<Box<dyn masking::ErasedMaskSerialize>> {
match webhook_transform_data {
Some(webhook_transform_data) => webhook_transform_data
.webhook_content
.as_ref()
.map(|webhook_response_content| {
get_ucs_webhook_resource_object(webhook_response_content)
})
.unwrap_or_else(|| {
connector
.get_webhook_resource_object(request_details)
.switch()
.attach_printable("Could not find resource object in incoming webhook body")
}),
None => connector
.get_webhook_resource_object(request_details)
.switch()
.attach_printable("Could not find resource object in incoming webhook body"),
}
}
/// Process the main webhook business logic after event type determination
#[allow(clippy::too_many_arguments)]
async fn process_webhook_business_logic(
state: &SessionState,
req_state: ReqState,
platform: &domain::Platform,
connector: &ConnectorEnum,
connector_name: &str,
event_type: webhooks::IncomingWebhookEvent,
source_verified_via_ucs: bool,
webhook_transform_data: &Option<Box<unified_connector_service::WebhookTransformData>>,
shadow_ucs_data: &mut Option<ShadowUcsData<'_>>,
request_details: &IncomingWebhookRequestDetails<'_>,
is_relay_webhook: bool,
) -> errors::RouterResult<WebhookResponseTracker> {
let object_ref_id = connector
.get_webhook_object_reference_id(request_details)
.switch()
.attach_printable("Could not find object reference id in incoming webhook body")?;
let connector_enum = Connector::from_str(connector_name)
.change_context(errors::ApiErrorResponse::InvalidDataValue {
field_name: "connector",
})
.attach_printable_lazy(|| format!("unable to parse connector name {connector_name:?}"))?;
let connectors_with_source_verification_call = &state.conf.webhook_source_verification_call;
let merchant_connector_account = match Box::pin(helper_utils::get_mca_from_object_reference_id(
state,
object_ref_id.clone(),
platform,
connector_name,
))
.await
{
Ok(mca) => mca,
Err(error) => {
let result = handle_incoming_webhook_error(
error,
connector,
connector_name,
request_details,
platform.get_processor().get_account().get_id(),
);
match result {
Ok((_, webhook_tracker, _)) => return Ok(webhook_tracker),
Err(e) => return Err(e),
}
}
};
let source_verified = if source_verified_via_ucs {
// If UCS handled verification, use that result
source_verified_via_ucs
} else {
// Fall back to traditional source verification
if connectors_with_source_verification_call
.connectors_with_webhook_source_verification_call
.contains(&connector_enum)
{
verify_webhook_source_verification_call(
connector.clone(),
state,
platform,
merchant_connector_account.clone(),
connector_name,
request_details,
)
.await
.or_else(|error| match error.current_context() {
errors::ConnectorError::WebhookSourceVerificationFailed => {
logger::error!(?error, "Source Verification Failed");
Ok(false)
}
_ => Err(error),
})
.switch()
.attach_printable("There was an issue in incoming webhook source verification")?
} else {
connector
.clone()
.verify_webhook_source(
request_details,
platform.get_processor().get_account().get_id(),
merchant_connector_account.connector_webhook_details.clone(),
merchant_connector_account.connector_account_details.clone(),
connector_name,
)
.await
.or_else(|error| match error.current_context() {
errors::ConnectorError::WebhookSourceVerificationFailed => {
logger::error!(?error, "Source Verification Failed");
Ok(false)
}
_ => Err(error),
})
.switch()
.attach_printable("There was an issue in incoming webhook source verification")?
}
};
if source_verified {
metrics::WEBHOOK_SOURCE_VERIFIED_COUNT.add(
1,
router_env::metric_attributes!((
MERCHANT_ID,
platform.get_processor().get_account().get_id().clone()
)),
);
} else if connector.is_webhook_source_verification_mandatory() {
// if webhook consumption is mandatory for connector, fail webhook
// so that merchant can retrigger it after updating merchant_secret
return Err(errors::ApiErrorResponse::WebhookAuthenticationFailed.into());
}
logger::info!(source_verified=?source_verified);
let event_object: Box<dyn masking::ErasedMaskSerialize> = match webhook_transform_data {
Some(webhook_transform_data) => {
// Extract resource_object from UCS webhook content
webhook_transform_data
.webhook_content
.as_ref()
.map(|webhook_response_content| {
get_ucs_webhook_resource_object(webhook_response_content)
})
.unwrap_or_else(|| {
// Fall back to connector extraction
connector
.get_webhook_resource_object(request_details)
.switch()
.attach_printable("Could not find resource object in incoming webhook body")
})?
}
None => {
// Use traditional connector extraction
connector
.get_webhook_resource_object(request_details)
.switch()
.attach_printable("Could not find resource object in incoming webhook body")?
}
};
let webhook_details = api::IncomingWebhookDetails {
object_reference_id: object_ref_id.clone(),
resource_object: serde_json::to_vec(&event_object)
.change_context(errors::ParsingError::EncodeError("byte-vec"))
.attach_printable("Unable to convert webhook payload to a value")
.change_context(errors::ApiErrorResponse::InternalServerError)
.attach_printable(
"There was an issue when encoding the incoming webhook body to bytes",
)?,
};
// Create shadow_event_object and shadow_webhook_details using shadow UCS data
let shadow_event_object: Option<Box<dyn masking::ErasedMaskSerialize>> =
shadow_ucs_data.as_ref().and_then(|shadow_data| {
// Create shadow event object using UCS transform data and shadow request details
let shadow_event_result = shadow_data
.ucs_transform_data
.webhook_content
.as_ref()
.map(|webhook_response_content| {
get_ucs_webhook_resource_object(webhook_response_content)
})
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | true |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/three_ds_decision_rule/utils.rs | crates/router/src/core/three_ds_decision_rule/utils.rs | use api_models::three_ds_decision_rule as api_threedsecure;
use common_types::three_ds_decision_rule_engine::ThreeDSDecision;
use euclid::backend::inputs as dsl_inputs;
use crate::{consts::PSD2_COUNTRIES, types::transformers::ForeignFrom};
// function to apply PSD2 validations to the decision
pub fn apply_psd2_validations_during_execute(
decision: ThreeDSDecision,
request: &api_models::three_ds_decision_rule::ThreeDsDecisionRuleExecuteRequest,
) -> ThreeDSDecision {
let issuer_in_psd2 = request
.issuer
.as_ref()
.and_then(|issuer| issuer.country)
.map(|country| PSD2_COUNTRIES.contains(&country))
.unwrap_or(false);
let acquirer_in_psd2 = request
.acquirer
.as_ref()
.and_then(|acquirer| acquirer.country)
.map(|country| PSD2_COUNTRIES.contains(&country))
.unwrap_or(false);
if issuer_in_psd2 && acquirer_in_psd2 {
// If both issuer and acquirer are in PSD2 region
match decision {
// If the decision is to enforce no 3DS, override it to enforce 3DS
ThreeDSDecision::NoThreeDs => ThreeDSDecision::ChallengeRequested,
_ => decision,
}
} else {
// If PSD2 doesn't apply, exemptions cannot be applied
match decision {
ThreeDSDecision::NoThreeDs => ThreeDSDecision::NoThreeDs,
// For all other decisions (including exemptions), enforce challenge as exemptions are only valid in PSD2 regions
_ => ThreeDSDecision::ChallengeRequested,
}
}
}
impl ForeignFrom<api_threedsecure::PaymentData> for dsl_inputs::PaymentInput {
fn foreign_from(request_payment_data: api_threedsecure::PaymentData) -> Self {
Self {
amount: request_payment_data.amount,
currency: request_payment_data.currency,
transaction_initiator: None,
authentication_type: None,
capture_method: None,
business_country: None,
billing_country: None,
business_label: None,
setup_future_usage: None,
card_bin: None,
extended_card_bin: None,
}
}
}
impl ForeignFrom<Option<api_threedsecure::PaymentMethodMetaData>>
for dsl_inputs::PaymentMethodInput
{
fn foreign_from(
request_payment_method_metadata: Option<api_threedsecure::PaymentMethodMetaData>,
) -> Self {
Self {
payment_method: None,
payment_method_type: None,
card_network: request_payment_method_metadata.and_then(|pm| pm.card_network),
}
}
}
impl ForeignFrom<api_threedsecure::CustomerDeviceData> for dsl_inputs::CustomerDeviceDataInput {
fn foreign_from(request_customer_device_data: api_threedsecure::CustomerDeviceData) -> Self {
Self {
platform: request_customer_device_data.platform,
device_type: request_customer_device_data.device_type,
display_size: request_customer_device_data.display_size,
}
}
}
impl ForeignFrom<api_threedsecure::IssuerData> for dsl_inputs::IssuerDataInput {
fn foreign_from(request_issuer_data: api_threedsecure::IssuerData) -> Self {
Self {
name: request_issuer_data.name,
country: request_issuer_data.country,
}
}
}
impl ForeignFrom<api_threedsecure::AcquirerData> for dsl_inputs::AcquirerDataInput {
fn foreign_from(request_acquirer_data: api_threedsecure::AcquirerData) -> Self {
Self {
country: request_acquirer_data.country,
fraud_rate: request_acquirer_data.fraud_rate,
}
}
}
impl ForeignFrom<api_threedsecure::ThreeDsDecisionRuleExecuteRequest> for dsl_inputs::BackendInput {
fn foreign_from(request: api_threedsecure::ThreeDsDecisionRuleExecuteRequest) -> Self {
Self {
metadata: None,
payment: dsl_inputs::PaymentInput::foreign_from(request.payment),
payment_method: dsl_inputs::PaymentMethodInput::foreign_from(request.payment_method),
mandate: dsl_inputs::MandateData {
mandate_acceptance_type: None,
mandate_type: None,
payment_type: None,
},
acquirer_data: request.acquirer.map(ForeignFrom::foreign_from),
customer_device_data: request.customer_device.map(ForeignFrom::foreign_from),
issuer_data: request.issuer.map(ForeignFrom::foreign_from),
}
}
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/mandate/helpers.rs | crates/router/src/core/mandate/helpers.rs | use api_models::payments as api_payments;
use common_enums::enums;
use common_types::payments as common_payments_types;
use common_utils::errors::CustomResult;
use diesel_models::Mandate;
use error_stack::ResultExt;
use hyperswitch_domain_models::mandates::MandateData;
use crate::{
core::{errors, payments},
routes::SessionState,
types::{api, domain},
};
#[cfg(feature = "v1")]
pub async fn get_profile_id_for_mandate(
state: &SessionState,
platform: &domain::Platform,
mandate: Mandate,
) -> CustomResult<common_utils::id_type::ProfileId, errors::ApiErrorResponse> {
let profile_id = if let Some(ref payment_id) = mandate.original_payment_id {
let pi = state
.store
.find_payment_intent_by_payment_id_merchant_id(
payment_id,
platform.get_processor().get_account().get_id(),
platform.get_processor().get_key_store(),
platform.get_processor().get_account().storage_scheme,
)
.await
.change_context(errors::ApiErrorResponse::PaymentNotFound)?;
let profile_id =
pi.profile_id
.clone()
.ok_or(errors::ApiErrorResponse::ProfileNotFound {
id: pi
.profile_id
.map(|profile_id| profile_id.get_string_repr().to_owned())
.unwrap_or_else(|| "Profile id is Null".to_string()),
})?;
Ok(profile_id)
} else {
Err(errors::ApiErrorResponse::PaymentNotFound)
}?;
Ok(profile_id)
}
pub fn get_mandate_type(
mandate_data: Option<api_payments::MandateData>,
off_session: Option<bool>,
setup_future_usage: Option<enums::FutureUsage>,
customer_acceptance: Option<common_payments_types::CustomerAcceptance>,
token: Option<String>,
payment_method: Option<enums::PaymentMethod>,
) -> CustomResult<Option<api::MandateTransactionType>, errors::ValidationError> {
match (
mandate_data.clone(),
off_session,
setup_future_usage,
customer_acceptance.or(mandate_data.and_then(|m_data| m_data.customer_acceptance)),
token,
payment_method,
) {
(Some(_), Some(_), Some(enums::FutureUsage::OffSession), Some(_), Some(_), _) => {
Err(errors::ValidationError::InvalidValue {
message: "Expected one out of recurring_details and mandate_data but got both"
.to_string(),
}
.into())
}
(_, _, Some(enums::FutureUsage::OffSession), Some(_), Some(_), _)
| (_, _, Some(enums::FutureUsage::OffSession), Some(_), _, _)
| (Some(_), _, Some(enums::FutureUsage::OffSession), _, _, _) => {
Ok(Some(api::MandateTransactionType::NewMandateTransaction))
}
(_, _, Some(enums::FutureUsage::OffSession), _, Some(_), _)
| (_, Some(_), _, _, _, _)
| (_, _, Some(enums::FutureUsage::OffSession), _, _, Some(enums::PaymentMethod::Wallet)) => {
Ok(Some(
api::MandateTransactionType::RecurringMandateTransaction,
))
}
_ => Ok(None),
}
}
#[derive(Clone)]
pub struct MandateGenericData {
pub token: Option<String>,
pub payment_method: Option<enums::PaymentMethod>,
pub payment_method_type: Option<enums::PaymentMethodType>,
pub mandate_data: Option<MandateData>,
pub recurring_mandate_payment_data:
Option<hyperswitch_domain_models::router_data::RecurringMandatePaymentData>,
pub mandate_connector: Option<payments::MandateConnectorDetails>,
pub payment_method_info: Option<domain::PaymentMethod>,
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
juspay/hyperswitch | https://github.com/juspay/hyperswitch/blob/4201e04a8f0f1d46b57f24868f4f943a9be50bda/crates/router/src/core/mandate/utils.rs | crates/router/src/core/mandate/utils.rs | use std::marker::PhantomData;
use common_utils::{errors::CustomResult, ext_traits::ValueExt};
use diesel_models::Mandate;
use error_stack::ResultExt;
use crate::{
core::{errors, payments::helpers},
types::{self, domain, PaymentAddress},
SessionState,
};
const IRRELEVANT_ATTEMPT_ID_IN_MANDATE_REVOKE_FLOW: &str =
"irrelevant_attempt_id_in_mandate_revoke_flow";
const IRRELEVANT_CONNECTOR_REQUEST_REFERENCE_ID_IN_MANDATE_REVOKE_FLOW: &str =
"irrelevant_connector_request_reference_id_in_mandate_revoke_flow";
pub async fn construct_mandate_revoke_router_data(
state: &SessionState,
merchant_connector_account: helpers::MerchantConnectorAccountType,
platform: &domain::Platform,
mandate: Mandate,
) -> CustomResult<types::MandateRevokeRouterData, errors::ApiErrorResponse> {
let auth_type: types::ConnectorAuthType = merchant_connector_account
.get_connector_account_details()
.parse_value("ConnectorAuthType")
.change_context(errors::ApiErrorResponse::InternalServerError)?;
let router_data = types::RouterData {
flow: PhantomData,
merchant_id: platform.get_processor().get_account().get_id().clone(),
customer_id: Some(mandate.customer_id),
tenant_id: state.tenant.tenant_id.clone(),
connector_customer: None,
connector: mandate.connector,
payment_id: mandate
.original_payment_id
.unwrap_or_else(|| {
common_utils::id_type::PaymentId::get_irrelevant_id("mandate_revoke")
})
.get_string_repr()
.to_owned(),
attempt_id: IRRELEVANT_ATTEMPT_ID_IN_MANDATE_REVOKE_FLOW.to_string(),
status: diesel_models::enums::AttemptStatus::default(),
payment_method: diesel_models::enums::PaymentMethod::default(),
payment_method_type: None,
connector_auth_type: auth_type,
description: None,
address: PaymentAddress::default(),
auth_type: diesel_models::enums::AuthenticationType::default(),
connector_meta_data: None,
connector_wallets_details: None,
amount_captured: None,
minor_amount_captured: None,
access_token: None,
session_token: None,
reference_id: None,
payment_method_token: None,
recurring_mandate_payment_data: None,
preprocessing_id: None,
payment_method_balance: None,
connector_api_version: None,
payment_method_status: None,
request: types::MandateRevokeRequestData {
mandate_id: mandate.mandate_id,
connector_mandate_id: mandate.connector_mandate_id,
},
response: Err(types::ErrorResponse::get_not_implemented()),
connector_request_reference_id:
IRRELEVANT_CONNECTOR_REQUEST_REFERENCE_ID_IN_MANDATE_REVOKE_FLOW.to_string(),
test_mode: None,
connector_http_status_code: None,
external_latency: None,
apple_pay_flow: None,
frm_metadata: None,
#[cfg(feature = "payouts")]
payout_method_data: None,
#[cfg(feature = "payouts")]
quote_id: None,
refund_id: None,
dispute_id: None,
payout_id: None,
connector_response: None,
integrity_check: Ok(()),
additional_merchant_data: None,
header_payload: None,
connector_mandate_request_reference_id: None,
authentication_id: None,
psd2_sca_exemption_type: None,
raw_connector_response: None,
is_payment_id_from_merchant: None,
l2_l3_data: None,
minor_amount_capturable: None,
authorized_amount: None,
};
Ok(router_data)
}
| rust | Apache-2.0 | 4201e04a8f0f1d46b57f24868f4f943a9be50bda | 2026-01-04T15:31:59.475325Z | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.