text stringlengths 70 351k | source stringclasses 4 values |
|---|---|
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/cache.rs | crate: router
use common_utils::errors::CustomResult;
use error_stack::{report, ResultExt};
use storage_impl::redis::cache::{redact_from_redis_and_publish, CacheKind};
use super::errors;
use crate::{routes::SessionState, services};
pub async fn invalidate(
state: SessionState,
key: &str,
) -> CustomResult<services::api::ApplicationResponse<serde_json::Value>, errors::ApiErrorResponse> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/locker_migration.rs | crate: router
use api_models::enums as api_enums;
use api_models::locker_migration::MigrateCardResponse;
use common_utils::{errors::CustomResult, id_type};
use diesel_models::enums as storage_enums;
use error_stack::FutureExt;
use error_stack::ResultExt;
use futures::TryFutureExt;
use super::errors::StorageErrorExt;
use super::payment_methods::cards;
use crate::services::logger;
use crate::types::api;
use crate::{errors, routes::SessionState, services, types::domain};
pub async fn rust_locker_migration(
state: SessionState,
merchant_id: &id_type::MerchantId,
) -> CustomResult<services::ApplicationResponse<MigrateCardResponse>, errors::ApiErrorResponse> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/locker_migration.rs | crate: router
use common_utils::{errors::CustomResult, id_type};
use super::errors::StorageErrorExt;
use crate::{errors, routes::SessionState, services, types::domain};
pub async fn call_to_locker(
_state: &SessionState,
_payment_methods: Vec<domain::PaymentMethod>,
_customer_id: &id_type::CustomerId,
_merchant_id: &id_type::MerchantId,
_merchant_account: &domain::MerchantAccount,
) -> CustomResult<usize, errors::ApiErrorResponse> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/locker_migration.rs | crate: router
use api_models::locker_migration::MigrateCardResponse;
use common_utils::{errors::CustomResult, id_type};
use super::errors::StorageErrorExt;
use crate::services::logger;
use crate::{errors, routes::SessionState, services, types::domain};
pub async fn rust_locker_migration(
_state: SessionState,
_merchant_id: &id_type::MerchantId,
) -> CustomResult<services::ApplicationResponse<MigrateCardResponse>, errors::ApiErrorResponse> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/locker_migration.rs | crate: router
use api_models::enums as api_enums;
use common_utils::{errors::CustomResult, id_type};
use diesel_models::enums as storage_enums;
use super::errors::StorageErrorExt;
use super::payment_methods::cards;
use crate::services::logger;
use crate::types::api;
use crate::{errors, routes::SessionState, services, types::domain};
pub async fn call_to_locker(
state: &SessionState,
payment_methods: Vec<domain::PaymentMethod>,
customer_id: &id_type::CustomerId,
merchant_id: &id_type::MerchantId,
merchant_account: &domain::MerchantAccount,
) -> CustomResult<usize, errors::ApiErrorResponse> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/conditional_config.rs | crate: router
use api_models::conditional_configs::DecisionManagerRequest;
use api_models::conditional_configs::{
DecisionManager, DecisionManagerRecord, DecisionManagerResponse,
};
use common_utils::ext_traits::StringExt;
use common_utils::types::keymanager::KeyManagerState;
use error_stack::ResultExt;
use crate::{
core::errors::{self, RouterResponse},
routes::SessionState,
services::api as service_api,
types::domain,
};
pub async fn delete_conditional_config(
state: SessionState,
key_store: domain::MerchantKeyStore,
merchant_account: domain::MerchantAccount,
) -> RouterResponse<()> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/conditional_config.rs | crate: router
use api_models::conditional_configs::DecisionManagerRequest;
use api_models::conditional_configs::{
DecisionManager, DecisionManagerRecord, DecisionManagerResponse,
};
use common_utils::ext_traits::StringExt;
use common_utils::types::keymanager::KeyManagerState;
use error_stack::ResultExt;
use crate::{
core::errors::{self, RouterResponse},
routes::SessionState,
services::api as service_api,
types::domain,
};
pub async fn upsert_conditional_config(
state: SessionState,
key_store: domain::MerchantKeyStore,
request: DecisionManagerRequest,
profile: domain::Profile,
) -> RouterResponse<common_types::payments::DecisionManagerRecord> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/conditional_config.rs | crate: router
use api_models::conditional_configs::{
DecisionManager, DecisionManagerRecord, DecisionManagerResponse,
};
use common_utils::types::keymanager::KeyManagerState;
use crate::{
core::errors::{self, RouterResponse},
routes::SessionState,
services::api as service_api,
types::domain,
};
pub async fn retrieve_conditional_config(
state: SessionState,
key_store: domain::MerchantKeyStore,
profile: domain::Profile,
) -> RouterResponse<common_types::payments::DecisionManagerResponse> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/conditional_config.rs | crate: router
use api_models::conditional_configs::{
DecisionManager, DecisionManagerRecord, DecisionManagerResponse,
};
use crate::{
core::errors::{self, RouterResponse},
routes::SessionState,
services::api as service_api,
types::domain,
};
pub async fn retrieve_conditional_config(
state: SessionState,
merchant_account: domain::MerchantAccount,
) -> RouterResponse<DecisionManagerResponse> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/conditional_config.rs | crate: router
use crate::{
core::errors::{self, RouterResponse},
routes::SessionState,
services::api as service_api,
types::domain,
};
pub async fn delete_conditional_config(
_state: SessionState,
_key_store: domain::MerchantKeyStore,
_merchant_account: domain::MerchantAccount,
) -> RouterResponse<()> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/conditional_config.rs | crate: router
use api_models::conditional_configs::DecisionManagerRequest;
use api_models::conditional_configs::{
DecisionManager, DecisionManagerRecord, DecisionManagerResponse,
};
use common_utils::ext_traits::StringExt;
use common_utils::types::keymanager::KeyManagerState;
use error_stack::ResultExt;
use crate::{
core::errors::{self, RouterResponse},
routes::SessionState,
services::api as service_api,
types::domain,
};
pub async fn upsert_conditional_config(
state: SessionState,
key_store: domain::MerchantKeyStore,
merchant_account: domain::MerchantAccount,
request: DecisionManager,
) -> RouterResponse<DecisionManagerRecord> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/fraud_check.rs | crate: router
use self::{
flows::{self as frm_flows, FeatureFrm},
types::{
self as frm_core_types, ConnectorDetailsCore, FrmConfigsObject, FrmData, FrmInfo,
PaymentDetails, PaymentToFrmData,
},
};
use super::errors::{ConnectorErrorExt, RouterResponse};
use crate::{
core::{
errors::{self, RouterResult},
payments::{self, flows::ConstructFlowSpecificData, operations::BoxedOperation},
},
db::StorageInterface,
routes::{app::ReqState, SessionState},
services,
types::{
self as oss_types,
api::{
fraud_check as frm_api, routing::FrmRoutingAlgorithm, Connector,
FraudCheckConnectorData, Fulfillment,
},
domain, fraud_check as frm_types,
storage::{
enums::{
AttemptStatus, FraudCheckLastStep, FraudCheckStatus, FraudCheckType, FrmSuggestion,
IntentStatus,
},
fraud_check::{FraudCheck, FraudCheckUpdate},
PaymentIntent,
},
},
utils::ValueExt,
};
pub async fn make_fulfillment_api_call(
db: &dyn StorageInterface,
fraud_check: FraudCheck,
payment_intent: PaymentIntent,
state: SessionState,
merchant_account: domain::MerchantAccount,
key_store: domain::MerchantKeyStore,
req: frm_core_types::FrmFulfillmentRequest,
) -> RouterResponse<frm_types::FraudCheckResponseData> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/fraud_check.rs | crate: router
use self::{
flows::{self as frm_flows, FeatureFrm},
types::{
self as frm_core_types, ConnectorDetailsCore, FrmConfigsObject, FrmData, FrmInfo,
PaymentDetails, PaymentToFrmData,
},
};
use super::errors::{ConnectorErrorExt, RouterResponse};
use crate::{
core::{
errors::{self, RouterResult},
payments::{self, flows::ConstructFlowSpecificData, operations::BoxedOperation},
},
db::StorageInterface,
routes::{app::ReqState, SessionState},
services,
types::{
self as oss_types,
api::{
fraud_check as frm_api, routing::FrmRoutingAlgorithm, Connector,
FraudCheckConnectorData, Fulfillment,
},
domain, fraud_check as frm_types,
storage::{
enums::{
AttemptStatus, FraudCheckLastStep, FraudCheckStatus, FraudCheckType, FrmSuggestion,
IntentStatus,
},
fraud_check::{FraudCheck, FraudCheckUpdate},
PaymentIntent,
},
},
utils::ValueExt,
};
pub async fn frm_fulfillment_core(
state: SessionState,
merchant_account: domain::MerchantAccount,
key_store: domain::MerchantKeyStore,
req: frm_core_types::FrmFulfillmentRequest,
) -> RouterResponse<frm_types::FraudCheckResponseData> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/fraud_check.rs | crate: router
use common_enums::CaptureMethod;
use router_env::{
logger,
tracing::{self, instrument},
};
use self::{
flows::{self as frm_flows, FeatureFrm},
types::{
self as frm_core_types, ConnectorDetailsCore, FrmConfigsObject, FrmData, FrmInfo,
PaymentDetails, PaymentToFrmData,
},
};
use crate::{
core::{
errors::{self, RouterResult},
payments::{self, flows::ConstructFlowSpecificData, operations::BoxedOperation},
},
db::StorageInterface,
routes::{app::ReqState, SessionState},
services,
types::{
self as oss_types,
api::{
fraud_check as frm_api, routing::FrmRoutingAlgorithm, Connector,
FraudCheckConnectorData, Fulfillment,
},
domain, fraud_check as frm_types,
storage::{
enums::{
AttemptStatus, FraudCheckLastStep, FraudCheckStatus, FraudCheckType, FrmSuggestion,
IntentStatus,
},
fraud_check::{FraudCheck, FraudCheckUpdate},
PaymentIntent,
},
},
utils::ValueExt,
};
pub async fn call_frm_before_connector_call<F, Req, D>(
operation: &BoxedOperation<'_, F, Req, D>,
merchant_account: &domain::MerchantAccount,
payment_data: &mut D,
state: &SessionState,
frm_info: &mut Option<FrmInfo<F, D>>,
customer: &Option<domain::Customer>,
should_continue_transaction: &mut bool,
should_continue_capture: &mut bool,
key_store: domain::MerchantKeyStore,
) -> RouterResult<Option<FrmConfigsObject>>
where
F: Send + Clone,
D: payments::OperationSessionGetters<F>
+ payments::OperationSessionSetters<F>
+ Send
+ Sync
+ Clone,
{
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/fraud_check.rs | crate: router
use masking::PeekInterface;
use self::{
flows::{self as frm_flows, FeatureFrm},
types::{
self as frm_core_types, ConnectorDetailsCore, FrmConfigsObject, FrmData, FrmInfo,
PaymentDetails, PaymentToFrmData,
},
};
use crate::{
core::{
errors::{self, RouterResult},
payments::{self, flows::ConstructFlowSpecificData, operations::BoxedOperation},
},
db::StorageInterface,
routes::{app::ReqState, SessionState},
services,
types::{
self as oss_types,
api::{
fraud_check as frm_api, routing::FrmRoutingAlgorithm, Connector,
FraudCheckConnectorData, Fulfillment,
},
domain, fraud_check as frm_types,
storage::{
enums::{
AttemptStatus, FraudCheckLastStep, FraudCheckStatus, FraudCheckType, FrmSuggestion,
IntentStatus,
},
fraud_check::{FraudCheck, FraudCheckUpdate},
PaymentIntent,
},
},
utils::ValueExt,
};
pub async fn make_frm_data_and_fraud_check_operation<F, D>(
_db: &dyn StorageInterface,
state: &SessionState,
merchant_account: &domain::MerchantAccount,
payment_data: D,
frm_routing_algorithm: FrmRoutingAlgorithm,
profile_id: common_utils::id_type::ProfileId,
frm_configs: FrmConfigsObject,
_customer: &Option<domain::Customer>,
) -> RouterResult<FrmInfo<F, D>>
where
F: Send + Clone,
D: payments::OperationSessionGetters<F>
+ payments::OperationSessionSetters<F>
+ Send
+ Sync
+ Clone,
{
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/fraud_check.rs | crate: router
use self::{
flows::{self as frm_flows, FeatureFrm},
types::{
self as frm_core_types, ConnectorDetailsCore, FrmConfigsObject, FrmData, FrmInfo,
PaymentDetails, PaymentToFrmData,
},
};
use crate::{
core::{
errors::{self, RouterResult},
payments::{self, flows::ConstructFlowSpecificData, operations::BoxedOperation},
},
db::StorageInterface,
routes::{app::ReqState, SessionState},
services,
types::{
self as oss_types,
api::{
fraud_check as frm_api, routing::FrmRoutingAlgorithm, Connector,
FraudCheckConnectorData, Fulfillment,
},
domain, fraud_check as frm_types,
storage::{
enums::{
AttemptStatus, FraudCheckLastStep, FraudCheckStatus, FraudCheckType, FrmSuggestion,
IntentStatus,
},
fraud_check::{FraudCheck, FraudCheckUpdate},
PaymentIntent,
},
},
utils::ValueExt,
};
fn from(payment_data: PaymentToFrmData) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/fraud_check.rs | crate: router
use std::fmt::Debug;
pub fn is_operation_allowed<Op: Debug>(operation: &Op) -> bool {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/fraud_check.rs | crate: router
use api_models::{self, enums as api_enums};
fn fraud_check_operation_by_frm_preferred_flow_type<F, D>(
frm_preferred_flow_type: api_enums::FrmPreferredFlowTypes,
) -> operation::BoxedFraudCheckOperation<F, D>
where
operation::FraudCheckPost: operation::FraudCheckOperation<F, D>,
operation::FraudCheckPre: operation::FraudCheckOperation<F, D>,
{
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/fraud_check.rs | crate: router
use self::{
flows::{self as frm_flows, FeatureFrm},
types::{
self as frm_core_types, ConnectorDetailsCore, FrmConfigsObject, FrmData, FrmInfo,
PaymentDetails, PaymentToFrmData,
},
};
use crate::{
core::{
errors::{self, RouterResult},
payments::{self, flows::ConstructFlowSpecificData, operations::BoxedOperation},
},
db::StorageInterface,
routes::{app::ReqState, SessionState},
services,
types::{
self as oss_types,
api::{
fraud_check as frm_api, routing::FrmRoutingAlgorithm, Connector,
FraudCheckConnectorData, Fulfillment,
},
domain, fraud_check as frm_types,
storage::{
enums::{
AttemptStatus, FraudCheckLastStep, FraudCheckStatus, FraudCheckType, FrmSuggestion,
IntentStatus,
},
fraud_check::{FraudCheck, FraudCheckUpdate},
PaymentIntent,
},
},
utils::ValueExt,
};
pub async fn should_call_frm<F, D>(
_merchant_account: &domain::MerchantAccount,
_payment_data: &D,
_state: &SessionState,
_key_store: domain::MerchantKeyStore,
) -> RouterResult<(
bool,
Option<FrmRoutingAlgorithm>,
Option<common_utils::id_type::ProfileId>,
Option<FrmConfigsObject>,
)>
where
F: Send + Clone,
D: payments::OperationSessionGetters<F> + Send + Sync + Clone,
{
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/fraud_check.rs | crate: router
use self::{
flows::{self as frm_flows, FeatureFrm},
types::{
self as frm_core_types, ConnectorDetailsCore, FrmConfigsObject, FrmData, FrmInfo,
PaymentDetails, PaymentToFrmData,
},
};
use crate::{
core::{
errors::{self, RouterResult},
payments::{self, flows::ConstructFlowSpecificData, operations::BoxedOperation},
},
db::StorageInterface,
routes::{app::ReqState, SessionState},
services,
types::{
self as oss_types,
api::{
fraud_check as frm_api, routing::FrmRoutingAlgorithm, Connector,
FraudCheckConnectorData, Fulfillment,
},
domain, fraud_check as frm_types,
storage::{
enums::{
AttemptStatus, FraudCheckLastStep, FraudCheckStatus, FraudCheckType, FrmSuggestion,
IntentStatus,
},
fraud_check::{FraudCheck, FraudCheckUpdate},
PaymentIntent,
},
},
utils::ValueExt,
};
pub async fn call_frm_service<D: Clone, F, Req, OperationData>(
state: &SessionState,
payment_data: &OperationData,
frm_data: &mut FrmData,
merchant_account: &domain::MerchantAccount,
key_store: &domain::MerchantKeyStore,
customer: &Option<domain::Customer>,
) -> RouterResult<oss_types::RouterData<F, Req, frm_types::FraudCheckResponseData>>
where
F: Send + Clone,
OperationData: payments::OperationSessionGetters<D> + Send + Sync + Clone,
// To create connector flow specific interface data
FrmData: ConstructFlowSpecificData<F, Req, frm_types::FraudCheckResponseData>,
oss_types::RouterData<F, Req, frm_types::FraudCheckResponseData>: FeatureFrm<F, Req> + Send,
// To construct connector flow specific api
dyn Connector: services::api::ConnectorIntegration<F, Req, frm_types::FraudCheckResponseData>,
{
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/fraud_check.rs | crate: router
use router_env::{
logger,
tracing::{self, instrument},
};
use self::{
flows::{self as frm_flows, FeatureFrm},
types::{
self as frm_core_types, ConnectorDetailsCore, FrmConfigsObject, FrmData, FrmInfo,
PaymentDetails, PaymentToFrmData,
},
};
use crate::{
core::{
errors::{self, RouterResult},
payments::{self, flows::ConstructFlowSpecificData, operations::BoxedOperation},
},
db::StorageInterface,
routes::{app::ReqState, SessionState},
services,
types::{
self as oss_types,
api::{
fraud_check as frm_api, routing::FrmRoutingAlgorithm, Connector,
FraudCheckConnectorData, Fulfillment,
},
domain, fraud_check as frm_types,
storage::{
enums::{
AttemptStatus, FraudCheckLastStep, FraudCheckStatus, FraudCheckType, FrmSuggestion,
IntentStatus,
},
fraud_check::{FraudCheck, FraudCheckUpdate},
PaymentIntent,
},
},
utils::ValueExt,
};
pub async fn post_payment_frm_core<F, D>(
state: &SessionState,
req_state: ReqState,
merchant_account: &domain::MerchantAccount,
payment_data: &mut D,
frm_info: &mut FrmInfo<F, D>,
frm_configs: FrmConfigsObject,
customer: &Option<domain::Customer>,
key_store: domain::MerchantKeyStore,
should_continue_capture: &mut bool,
platform_merchant_account: Option<&domain::MerchantAccount>,
) -> RouterResult<Option<FrmData>>
where
F: Send + Clone,
D: payments::OperationSessionGetters<F>
+ payments::OperationSessionSetters<F>
+ Send
+ Sync
+ Clone,
{
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/fraud_check.rs | crate: router
use api_models::{self, enums as api_enums};
use router_env::{
logger,
tracing::{self, instrument},
};
use self::{
flows::{self as frm_flows, FeatureFrm},
types::{
self as frm_core_types, ConnectorDetailsCore, FrmConfigsObject, FrmData, FrmInfo,
PaymentDetails, PaymentToFrmData,
},
};
use crate::{
core::{
errors::{self, RouterResult},
payments::{self, flows::ConstructFlowSpecificData, operations::BoxedOperation},
},
db::StorageInterface,
routes::{app::ReqState, SessionState},
services,
types::{
self as oss_types,
api::{
fraud_check as frm_api, routing::FrmRoutingAlgorithm, Connector,
FraudCheckConnectorData, Fulfillment,
},
domain, fraud_check as frm_types,
storage::{
enums::{
AttemptStatus, FraudCheckLastStep, FraudCheckStatus, FraudCheckType, FrmSuggestion,
IntentStatus,
},
fraud_check::{FraudCheck, FraudCheckUpdate},
PaymentIntent,
},
},
utils::ValueExt,
};
pub async fn pre_payment_frm_core<F, Req, D>(
state: &SessionState,
merchant_account: &domain::MerchantAccount,
payment_data: &mut D,
frm_info: &mut FrmInfo<F, D>,
frm_configs: FrmConfigsObject,
customer: &Option<domain::Customer>,
should_continue_transaction: &mut bool,
should_continue_capture: &mut bool,
key_store: domain::MerchantKeyStore,
operation: &BoxedOperation<'_, F, Req, D>,
) -> RouterResult<Option<FrmData>>
where
F: Send + Clone,
D: payments::OperationSessionGetters<F>
+ payments::OperationSessionSetters<F>
+ Send
+ Sync
+ Clone,
{
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/fraud_check.rs | crate: router
Option<FrmConfigsObject>,
)>
where
F: Send + Clone,
D: payments::OperationSessionGetters<F> + Send + Sync + Clone,
{
// Frm routing algorithm is not present in the merchant account
// it has to be fetched from the business profile
todo!()
}
#[cfg(feature = "v1")]
pub async fn should_call_frm<F, D>(
merchant_account: &domain::MerchantAccount,
payment_data: &D,
state: &SessionState,
key_store: domain::MerchantKeyStore,
) -> RouterResult<(
bool,
Option<FrmRoutingAlgorithm>,
Option<common_utils::id_type::ProfileId>,
Option<FrmConfigsObject>,
)>
where
F: Send + Clone,
pub async fn should_call_frm<F, D>(
merchant_account: &domain::MerchantAccount,
payment_data: &D,
state: &SessionState,
key_store: domain::MerchantKeyStore,
) -> RouterResult<(
bool,
Option<FrmRoutingAlgorithm>,
Option<common_utils::id_type::ProfileId>,
Option<FrmConfigsObject>,
)>
where
F: Send + Clone,
D: payments::OperationSessionGetters<F> + Send + Sync + Clone,
{
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/configs.rs | crate: router
use crate::{
core::errors::{self, utils::StorageErrorExt, RouterResponse},
routes::SessionState,
services::ApplicationResponse,
types::{api, transformers::ForeignInto},
};
pub async fn config_delete(state: SessionState, key: String) -> RouterResponse<api::Config> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/configs.rs | crate: router
use crate::{
core::errors::{self, utils::StorageErrorExt, RouterResponse},
routes::SessionState,
services::ApplicationResponse,
types::{api, transformers::ForeignInto},
};
pub async fn update_config(
state: SessionState,
config_update: &api::ConfigUpdate,
) -> RouterResponse<api::Config> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/configs.rs | crate: router
use crate::{
core::errors::{self, utils::StorageErrorExt, RouterResponse},
routes::SessionState,
services::ApplicationResponse,
types::{api, transformers::ForeignInto},
};
pub async fn read_config(state: SessionState, key: &str) -> RouterResponse<api::Config> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/configs.rs | crate: router
use crate::{
core::errors::{self, utils::StorageErrorExt, RouterResponse},
routes::SessionState,
services::ApplicationResponse,
types::{api, transformers::ForeignInto},
};
pub async fn set_config(state: SessionState, config: api::Config) -> RouterResponse<api::Config> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/encryption.rs | crate: router
use common_utils::{
keymanager::transfer_key_to_key_manager,
types::keymanager::{EncryptionTransferRequest, Identifier},
};
use crate::{consts::BASE64_ENGINE, errors, types::domain::UserKeyStore, SessionState};
pub async fn send_request_to_key_service_for_user(
state: &SessionState,
keys: Vec<UserKeyStore>,
) -> errors::CustomResult<usize, errors::ApiErrorResponse> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/encryption.rs | crate: router
use common_utils::{
keymanager::transfer_key_to_key_manager,
types::keymanager::{EncryptionTransferRequest, Identifier},
};
use hyperswitch_domain_models::merchant_key_store::MerchantKeyStore;
use crate::{consts::BASE64_ENGINE, errors, types::domain::UserKeyStore, SessionState};
pub async fn send_request_to_key_service_for_merchant(
state: &SessionState,
keys: Vec<MerchantKeyStore>,
) -> errors::CustomResult<usize, errors::ApiErrorResponse> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/encryption.rs | crate: router
use api_models::admin::MerchantKeyTransferRequest;
use crate::{consts::BASE64_ENGINE, errors, types::domain::UserKeyStore, SessionState};
pub async fn transfer_encryption_key(
state: &SessionState,
req: MerchantKeyTransferRequest,
) -> errors::CustomResult<usize, errors::ApiErrorResponse> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/blocklist.rs | crate: router
use api_models::blocklist as api_blocklist;
use crate::{
core::errors::{self, RouterResponse},
routes::SessionState,
services,
types::domain,
};
pub async fn toggle_blocklist_guard(
state: SessionState,
merchant_account: domain::MerchantAccount,
query: api_blocklist::ToggleBlocklistQuery,
) -> RouterResponse<api_blocklist::ToggleBlocklistResponse> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/blocklist.rs | crate: router
use api_models::blocklist as api_blocklist;
use crate::{
core::errors::{self, RouterResponse},
routes::SessionState,
services,
types::domain,
};
pub async fn list_blocklist_entries(
state: SessionState,
merchant_account: domain::MerchantAccount,
query: api_blocklist::ListBlocklistQuery,
) -> RouterResponse<Vec<api_blocklist::BlocklistResponse>> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/blocklist.rs | crate: router
use api_models::blocklist as api_blocklist;
use crate::{
core::errors::{self, RouterResponse},
routes::SessionState,
services,
types::domain,
};
pub async fn remove_entry_from_blocklist(
state: SessionState,
merchant_account: domain::MerchantAccount,
body: api_blocklist::DeleteFromBlocklistRequest,
) -> RouterResponse<api_blocklist::DeleteFromBlocklistResponse> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/blocklist.rs | crate: router
use api_models::blocklist as api_blocklist;
use crate::{
core::errors::{self, RouterResponse},
routes::SessionState,
services,
types::domain,
};
pub async fn add_entry_to_blocklist(
state: SessionState,
merchant_account: domain::MerchantAccount,
body: api_blocklist::AddToBlocklistRequest,
) -> RouterResponse<api_blocklist::AddToBlocklistResponse> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/files.rs | crate: router
use super::errors::{self, RouterResponse};
use crate::{
consts,
routes::SessionState,
services::ApplicationResponse,
types::{api, domain},
};
pub async fn files_retrieve_core(
state: SessionState,
merchant_account: domain::MerchantAccount,
key_store: domain::MerchantKeyStore,
req: api::FileId,
) -> RouterResponse<serde_json::Value> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/files.rs | crate: router
use api_models::files;
use super::errors::{self, RouterResponse};
use crate::{
consts,
routes::SessionState,
services::ApplicationResponse,
types::{api, domain},
};
pub async fn files_create_core(
state: SessionState,
merchant_account: domain::MerchantAccount,
key_store: domain::MerchantKeyStore,
create_file_request: api::CreateFileRequest,
) -> RouterResponse<files::CreateFileResponse> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/files.rs | crate: router
use super::errors::{self, RouterResponse};
use crate::{
consts,
routes::SessionState,
services::ApplicationResponse,
types::{api, domain},
};
pub async fn files_delete_core(
state: SessionState,
merchant_account: domain::MerchantAccount,
req: api::FileId,
) -> RouterResponse<serde_json::Value> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/currency.rs | crate: router
use analytics::errors::AnalyticsError;
use common_utils::errors::CustomResult;
use currency_conversion::types::ExchangeRates;
use router_env::logger;
use crate::{
consts::DEFAULT_ANALYTICS_FOREX_RETRY_ATTEMPTS,
core::errors::ApiErrorResponse,
services::ApplicationResponse,
utils::currency::{self, convert_currency, get_forex_rates, ForexError as ForexCacheError},
SessionState,
};
pub async fn get_forex_exchange_rates(
state: SessionState,
) -> CustomResult<ExchangeRates, AnalyticsError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/currency.rs | crate: router
use common_utils::errors::CustomResult;
use crate::{
consts::DEFAULT_ANALYTICS_FOREX_RETRY_ATTEMPTS,
core::errors::ApiErrorResponse,
services::ApplicationResponse,
utils::currency::{self, convert_currency, get_forex_rates, ForexError as ForexCacheError},
SessionState,
};
pub async fn convert_forex(
state: SessionState,
amount: i64,
to_currency: String,
from_currency: String,
) -> CustomResult<
ApplicationResponse<api_models::currency::CurrencyConversionResponse>,
ApiErrorResponse,
> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/currency.rs | crate: router
use common_utils::errors::CustomResult;
use crate::{
consts::DEFAULT_ANALYTICS_FOREX_RETRY_ATTEMPTS,
core::errors::ApiErrorResponse,
services::ApplicationResponse,
utils::currency::{self, convert_currency, get_forex_rates, ForexError as ForexCacheError},
SessionState,
};
pub async fn retrieve_forex(
state: SessionState,
) -> CustomResult<ApplicationResponse<currency::FxExchangeRatesCacheEntry>, ApiErrorResponse> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/surcharge_decision_config.rs | crate: router
use api_models::surcharge_decision_configs::{
SurchargeDecisionConfigReq, SurchargeDecisionManagerRecord, SurchargeDecisionManagerResponse,
};
use common_utils::ext_traits::StringExt;
use error_stack::ResultExt;
use crate::{
core::errors::{self, RouterResponse},
routes::SessionState,
services::api as service_api,
types::domain,
};
pub async fn delete_surcharge_decision_config(
state: SessionState,
key_store: domain::MerchantKeyStore,
merchant_account: domain::MerchantAccount,
) -> RouterResponse<()> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/surcharge_decision_config.rs | crate: router
use api_models::surcharge_decision_configs::{
SurchargeDecisionConfigReq, SurchargeDecisionManagerRecord, SurchargeDecisionManagerResponse,
};
use crate::{
core::errors::{self, RouterResponse},
routes::SessionState,
services::api as service_api,
types::domain,
};
pub async fn retrieve_surcharge_decision_config(
state: SessionState,
merchant_account: domain::MerchantAccount,
) -> RouterResponse<SurchargeDecisionManagerResponse> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/surcharge_decision_config.rs | crate: router
use crate::{
core::errors::{self, RouterResponse},
routes::SessionState,
services::api as service_api,
types::domain,
};
pub async fn delete_surcharge_decision_config(
_state: SessionState,
_key_store: domain::MerchantKeyStore,
_merchant_account: domain::MerchantAccount,
) -> RouterResponse<()> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/surcharge_decision_config.rs | crate: router
use api_models::surcharge_decision_configs::{
SurchargeDecisionConfigReq, SurchargeDecisionManagerRecord, SurchargeDecisionManagerResponse,
};
use crate::{
core::errors::{self, RouterResponse},
routes::SessionState,
services::api as service_api,
types::domain,
};
pub async fn upsert_surcharge_decision_config(
_state: SessionState,
_key_store: domain::MerchantKeyStore,
_merchant_account: domain::MerchantAccount,
_request: SurchargeDecisionConfigReq,
) -> RouterResponse<SurchargeDecisionManagerRecord> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/surcharge_decision_config.rs | crate: router
use api_models::surcharge_decision_configs::{
SurchargeDecisionConfigReq, SurchargeDecisionManagerRecord, SurchargeDecisionManagerResponse,
};
use common_utils::ext_traits::StringExt;
use error_stack::ResultExt;
use crate::{
core::errors::{self, RouterResponse},
routes::SessionState,
services::api as service_api,
types::domain,
};
pub async fn upsert_surcharge_decision_config(
state: SessionState,
key_store: domain::MerchantKeyStore,
merchant_account: domain::MerchantAccount,
request: SurchargeDecisionConfigReq,
) -> RouterResponse<SurchargeDecisionManagerRecord> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/connector_onboarding.rs | crate: router
use api_models::{connector_onboarding as api, enums};
use masking::Secret;
use crate::{
core::errors::{ApiErrorResponse, RouterResponse, RouterResult},
routes::app::ReqState,
services::{authentication as auth, ApplicationResponse},
types as oss_types,
utils::connector_onboarding as utils,
SessionState,
};
pub async fn sync_onboarding_status(
state: SessionState,
user_from_token: auth::UserFromToken,
request: api::OnboardingSyncRequest,
_req_state: ReqState,
) -> RouterResponse<api::OnboardingStatus> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/connector_onboarding.rs | crate: router
use api_models::{connector_onboarding as api, enums};
use crate::{
core::errors::{ApiErrorResponse, RouterResponse, RouterResult},
routes::app::ReqState,
services::{authentication as auth, ApplicationResponse},
types as oss_types,
utils::connector_onboarding as utils,
SessionState,
};
pub async fn get_action_url(
state: SessionState,
user_from_token: auth::UserFromToken,
request: api::ActionUrlRequest,
_req_state: ReqState,
) -> RouterResponse<api::ActionUrlResponse> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/connector_onboarding.rs | crate: router
use api_models::{connector_onboarding as api, enums};
use crate::{
core::errors::{ApiErrorResponse, RouterResponse, RouterResult},
routes::app::ReqState,
services::{authentication as auth, ApplicationResponse},
types as oss_types,
utils::connector_onboarding as utils,
SessionState,
};
pub async fn reset_tracking_id(
state: SessionState,
user_from_token: auth::UserFromToken,
request: api::ResetTrackingIdRequest,
_req_state: ReqState,
) -> RouterResponse<()> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/payment_methods.rs | crate: router
use common_utils::{ext_traits::OptionExt, id_type};
use super::errors;
use crate::{db::errors::StorageErrorExt, routes, types::domain};
pub async fn list_payment_methods(
state: routes::SessionState,
merchant_account: domain::MerchantAccount,
profile: domain::Profile,
key_store: domain::MerchantKeyStore,
payment_id: id_type::GlobalPaymentId,
_req: api_models::payments::PaymentMethodsListRequest,
header_payload: &hyperswitch_domain_models::payments::HeaderPayload,
) -> errors::RouterResponse<api_models::payments::PaymentMethodListResponseForPayments> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/payment_methods.rs | crate: router
use super::errors;
use crate::{db::errors::StorageErrorExt, routes, types::domain};
/// Validate if payment methods list can be performed on the current status of payment intent
fn validate_payment_status_for_payment_method_list(
intent_status: common_enums::IntentStatus,
) -> Result<(), errors::ApiErrorResponse> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/payment_methods.rs | crate: router
fn perform_filtering(self) -> FilteredPaymentMethodsEnabled {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/payment_methods.rs | crate: router
fn perform_surcharge_calculation(
self,
) -> RequiredFieldsAndSurchargeForEnabledPaymentMethodTypes {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/payment_methods.rs | crate: router
fn generate_response(self) -> api_models::payments::PaymentMethodListResponseForPayments {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/payment_methods.rs | crate: router
fn get_required_fields(
self,
_input: RequiredFieldsInput,
) -> RequiredFieldsForEnabledPaymentMethodTypes {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/payment_methods.rs | crate: router
fn new() -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/conditional_configs.rs | crate: router
use api_models::{conditional_configs::DecisionManagerRecord, routing};
use common_utils::ext_traits::StringExt;
use euclid::backend::{self, inputs as dsl_inputs, EuclidBackend};
use storage_impl::redis::cache::{self, DECISION_MANAGER_CACHE};
use super::routing::make_dsl_input;
use crate::{core::errors::RouterResult, types::domain};
use crate::{
core::{errors, errors::ConditionalConfigError as ConfigError, routing as core_routing},
routes,
};
pub type ConditionalConfigResult<O> = errors::CustomResult<O, ConfigError>;
pub async fn perform_decision_management(
state: &routes::SessionState,
algorithm_ref: routing::RoutingAlgorithmRef,
merchant_id: &common_utils::id_type::MerchantId,
payment_data: &core_routing::PaymentsDslInput<'_>,
) -> ConditionalConfigResult<common_types::payments::ConditionalConfigs> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/conditional_configs.rs | crate: router
use euclid::backend::{self, inputs as dsl_inputs, EuclidBackend};
use crate::{
core::{errors, errors::ConditionalConfigError as ConfigError, routing as core_routing},
routes,
};
pub type ConditionalConfigResult<O> = errors::CustomResult<O, ConfigError>;
pub fn execute_dsl_and_get_conditional_config(
backend_input: dsl_inputs::BackendInput,
interpreter: &backend::VirInterpreterBackend<common_types::payments::ConditionalConfigs>,
) -> ConditionalConfigResult<common_types::payments::ConditionalConfigs> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/conditional_configs.rs | crate: router
use api_models::{conditional_configs::DecisionManagerRecord, routing};
use euclid::backend::{self, inputs as dsl_inputs, EuclidBackend};
use super::routing::make_dsl_input;
use crate::{core::errors::RouterResult, types::domain};
use crate::{
core::{errors, errors::ConditionalConfigError as ConfigError, routing as core_routing},
routes,
};
pub type ConditionalConfigResult<O> = errors::CustomResult<O, ConfigError>;
pub fn perform_decision_management(
record: common_types::payments::DecisionManagerRecord,
payment_data: &core_routing::PaymentsDslInput<'_>,
) -> RouterResult<common_types::payments::ConditionalConfigs> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/flows.rs | crate: router
use hyperswitch_domain_models::{
mandates::CustomerAcceptance,
router_flow_types::{
Authenticate, AuthenticationConfirmation, PostAuthenticate, PreAuthenticate,
},
router_request_types::PaymentsCaptureData,
};
use hyperswitch_interfaces::api::{
payouts::Payouts, UasAuthentication, UasAuthenticationConfirmation, UasPostAuthentication,
UasPreAuthentication, UnifiedAuthenticationService,
};
use crate::types::fraud_check as frm_types;
use crate::{
connector,
core::{
errors::{ApiErrorResponse, ConnectorError, CustomResult, RouterResult},
payments::{self, helpers},
},
logger,
routes::SessionState,
services, types as router_types,
types::{self, api, api::enums as api_enums, domain},
};
/// Processes the response from the capture flow and determines the final status and the response.
fn handle_post_capture_response(
authorize_router_data_response: types::PaymentsResponseData,
post_capture_router_data: Result<
types::RouterData<api::Capture, PaymentsCaptureData, types::PaymentsResponseData>,
error_stack::Report<ApiErrorResponse>,
>,
) -> RouterResult<(common_enums::AttemptStatus, types::PaymentsResponseData)> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/flows.rs | crate: router
use hyperswitch_domain_models::router_flow_types::{
BillingConnectorPaymentsSync, RecoveryRecordBack,
};
use hyperswitch_domain_models::{
mandates::CustomerAcceptance,
router_flow_types::{
Authenticate, AuthenticationConfirmation, PostAuthenticate, PreAuthenticate,
},
router_request_types::PaymentsCaptureData,
};
use hyperswitch_interfaces::api::{
payouts::Payouts, UasAuthentication, UasAuthenticationConfirmation, UasPostAuthentication,
UasPreAuthentication, UnifiedAuthenticationService,
};
use crate::types::fraud_check as frm_types;
use crate::{
connector,
core::{
errors::{ApiErrorResponse, ConnectorError, CustomResult, RouterResult},
payments::{self, helpers},
},
logger,
routes::SessionState,
services, types as router_types,
types::{self, api, api::enums as api_enums, domain},
};
/// Executes a capture request by building a connector-specific request and deciding
/// the appropriate flow to send it to the payment connector.
pub async fn call_capture_request(
mut capture_router_data: types::RouterData<
api::Capture,
PaymentsCaptureData,
types::PaymentsResponseData,
>,
state: &SessionState,
connector: &api::ConnectorData,
call_connector_action: payments::CallConnectorAction,
business_profile: &domain::Profile,
header_payload: hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<types::RouterData<api::Capture, PaymentsCaptureData, types::PaymentsResponseData>>
{
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/flows.rs | crate: router
use hyperswitch_domain_models::{
mandates::CustomerAcceptance,
router_flow_types::{
Authenticate, AuthenticationConfirmation, PostAuthenticate, PreAuthenticate,
},
router_request_types::PaymentsCaptureData,
};
use crate::{
connector,
core::{
errors::{ApiErrorResponse, ConnectorError, CustomResult, RouterResult},
payments::{self, helpers},
},
logger,
routes::SessionState,
services, types as router_types,
types::{self, api, api::enums as api_enums, domain},
};
/// Determines whether a capture API call should be made for a payment attempt
/// This function evaluates whether an authorized payment should proceed with a capture API call
/// based on various payment parameters. It's primarily used in two-step (auth + capture) payment flows for CaptureMethod SequentialAutomatic
///
pub fn should_initiate_capture_flow(
connector_name: &router_types::Connector,
customer_acceptance: Option<CustomerAcceptance>,
capture_method: Option<api_enums::CaptureMethod>,
setup_future_usage: Option<api_enums::FutureUsage>,
status: common_enums::AttemptStatus,
) -> bool {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/flows.rs | crate: router
use crate::{
connector,
core::{
errors::{ApiErrorResponse, ConnectorError, CustomResult, RouterResult},
payments::{self, helpers},
},
logger,
routes::SessionState,
services, types as router_types,
types::{self, api, api::enums as api_enums, domain},
};
fn get_flow_type(
&self,
_query_params: &str,
_json_payload: Option<serde_json::Value>,
_action: services::PaymentAction,
) -> CustomResult<payments::CallConnectorAction, ConnectorError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/flows.rs | crate: router
use hyperswitch_interfaces::api::{
payouts::Payouts, UasAuthentication, UasAuthenticationConfirmation, UasPostAuthentication,
UasPreAuthentication, UnifiedAuthenticationService,
};
use crate::{
connector,
core::{
errors::{ApiErrorResponse, ConnectorError, CustomResult, RouterResult},
payments::{self, helpers},
},
logger,
routes::SessionState,
services, types as router_types,
types::{self, api, api::enums as api_enums, domain},
};
/// Returns the connector request and a bool which specifies whether to proceed with further
async fn build_flow_specific_connector_request(
&mut self,
_state: &SessionState,
_connector: &api::ConnectorData,
_call_connector_action: payments::CallConnectorAction,
) -> RouterResult<(Option<services::Request>, bool)> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/flows.rs | crate: router
use hyperswitch_interfaces::api::{
payouts::Payouts, UasAuthentication, UasAuthenticationConfirmation, UasPostAuthentication,
UasPreAuthentication, UnifiedAuthenticationService,
};
use crate::types::fraud_check as frm_types;
use crate::{
connector,
core::{
errors::{ApiErrorResponse, ConnectorError, CustomResult, RouterResult},
payments::{self, helpers},
},
logger,
routes::SessionState,
services, types as router_types,
types::{self, api, api::enums as api_enums, domain},
};
async fn create_connector_customer<'a>(
&self,
_state: &SessionState,
_connector: &api::ConnectorData,
) -> RouterResult<Option<String>>
where
F: Clone,
Self: Sized,
dyn api::Connector: services::ConnectorIntegration<F, T, types::PaymentsResponseData>,
{
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/flows.rs | crate: router
use hyperswitch_interfaces::api::{
payouts::Payouts, UasAuthentication, UasAuthenticationConfirmation, UasPostAuthentication,
UasPreAuthentication, UnifiedAuthenticationService,
};
use crate::types::fraud_check as frm_types;
use crate::{
connector,
core::{
errors::{ApiErrorResponse, ConnectorError, CustomResult, RouterResult},
payments::{self, helpers},
},
logger,
routes::SessionState,
services, types as router_types,
types::{self, api, api::enums as api_enums, domain},
};
async fn postprocessing_steps<'a>(
self,
_state: &SessionState,
_connector: &api::ConnectorData,
) -> RouterResult<Self>
where
F: Clone,
Self: Sized,
dyn api::Connector: services::ConnectorIntegration<F, T, types::PaymentsResponseData>,
{
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/flows.rs | crate: router
use hyperswitch_interfaces::api::{
payouts::Payouts, UasAuthentication, UasAuthenticationConfirmation, UasPostAuthentication,
UasPreAuthentication, UnifiedAuthenticationService,
};
use crate::types::fraud_check as frm_types;
use crate::{
connector,
core::{
errors::{ApiErrorResponse, ConnectorError, CustomResult, RouterResult},
payments::{self, helpers},
},
logger,
routes::SessionState,
services, types as router_types,
types::{self, api, api::enums as api_enums, domain},
};
async fn preprocessing_steps<'a>(
self,
_state: &SessionState,
_connector: &api::ConnectorData,
) -> RouterResult<Self>
where
F: Clone,
Self: Sized,
dyn api::Connector: services::ConnectorIntegration<F, T, types::PaymentsResponseData>,
{
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/flows.rs | crate: router
use hyperswitch_interfaces::api::{
payouts::Payouts, UasAuthentication, UasAuthenticationConfirmation, UasPostAuthentication,
UasPreAuthentication, UnifiedAuthenticationService,
};
use crate::types::fraud_check as frm_types;
use crate::{
connector,
core::{
errors::{ApiErrorResponse, ConnectorError, CustomResult, RouterResult},
payments::{self, helpers},
},
logger,
routes::SessionState,
services, types as router_types,
types::{self, api, api::enums as api_enums, domain},
};
async fn add_payment_method_token<'a>(
&mut self,
_state: &SessionState,
_connector: &api::ConnectorData,
_tokenization_action: &payments::TokenizationAction,
_should_continue_payment: bool,
) -> RouterResult<types::PaymentMethodTokenResult>
where
F: Clone,
Self: Sized,
dyn api::Connector: services::ConnectorIntegration<F, T, types::PaymentsResponseData>,
{
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/flows.rs | crate: router
use hyperswitch_interfaces::api::{
payouts::Payouts, UasAuthentication, UasAuthenticationConfirmation, UasPostAuthentication,
UasPreAuthentication, UnifiedAuthenticationService,
};
use crate::types::fraud_check as frm_types;
use crate::{
connector,
core::{
errors::{ApiErrorResponse, ConnectorError, CustomResult, RouterResult},
payments::{self, helpers},
},
logger,
routes::SessionState,
services, types as router_types,
types::{self, api, api::enums as api_enums, domain},
};
async fn add_session_token<'a>(
self,
_state: &SessionState,
_connector: &api::ConnectorData,
) -> RouterResult<Self>
where
F: Clone,
Self: Sized,
dyn api::Connector: services::ConnectorIntegration<F, T, types::PaymentsResponseData>,
{
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/operations/payment_status.rs | crate: router
use api_models::enums::FrmSuggestion;
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,
};
type PaymentStatusOperation<'b, F, R> = BoxedOperation<'b, F, R, PaymentData<F>>;
async fn update_trackers<'b>(
&'b self,
_state: &'b SessionState,
req_state: ReqState,
payment_data: PaymentData<F>,
_customer: Option<domain::Customer>,
_storage_scheme: enums::MerchantStorageScheme,
_updated_customer: Option<storage::CustomerUpdate>,
_key_store: &domain::MerchantKeyStore,
_frm_suggestion: Option<FrmSuggestion>,
_header_payload: hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<(
PaymentStatusOperation<'b, F, api::PaymentsRetrieveRequest>,
PaymentData<F>,
)>
where
F: 'b + Send,
{
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/operations/payment_status.rs | crate: router
use api_models::enums::FrmSuggestion;
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,
};
type PaymentStatusOperation<'b, F, R> = BoxedOperation<'b, F, R, PaymentData<F>>;
async fn update_trackers<'b>(
&'b self,
_state: &'b SessionState,
req_state: ReqState,
payment_data: PaymentData<F>,
_customer: Option<domain::Customer>,
_storage_scheme: enums::MerchantStorageScheme,
_updated_customer: Option<storage::CustomerUpdate>,
_key_store: &domain::MerchantKeyStore,
_frm_suggestion: Option<FrmSuggestion>,
_header_payload: hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<(
PaymentStatusOperation<'b, F, api::PaymentsRequest>,
PaymentData<F>,
)>
where
F: 'b + Send,
{
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/operations/payment_status.rs | crate: router
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,
};
type PaymentStatusOperation<'b, F, R> = BoxedOperation<'b, F, R, PaymentData<F>>;
fn validate_request<'b>(
&'b self,
request: &api::PaymentsRetrieveRequest,
merchant_account: &domain::MerchantAccount,
) -> RouterResult<(
PaymentStatusOperation<'b, F, api::PaymentsRetrieveRequest>,
operations::ValidateResult,
)> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/operations/payment_status.rs | crate: router
use api_models::enums::FrmSuggestion;
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,
};
type PaymentStatusOperation<'b, F, R> = BoxedOperation<'b, F, R, PaymentData<F>>;
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,
_merchant_account: &domain::MerchantAccount,
_key_store: &domain::MerchantKeyStore,
_state: &SessionState,
_request: &api::PaymentsRetrieveRequest,
_operation: Op,
_storage_scheme: enums::MerchantStorageScheme,
) -> RouterResult<operations::GetTrackerResponse<'a, F, api::PaymentsRetrieveRequest, PaymentData<F>>>
{
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/operations/payment_status.rs | crate: router
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,
};
type PaymentStatusOperation<'b, F, R> = BoxedOperation<'b, F, R, PaymentData<F>>;
async fn get_trackers<'a>(
&'a self,
state: &'a SessionState,
payment_id: &api::PaymentIdType,
request: &api::PaymentsRetrieveRequest,
merchant_account: &domain::MerchantAccount,
key_store: &domain::MerchantKeyStore,
_auth_flow: services::AuthFlow,
_header_payload: &hyperswitch_domain_models::payments::HeaderPayload,
platform_merchant_account: Option<&domain::MerchantAccount>,
) -> RouterResult<
operations::GetTrackerResponse<'a, F, api::PaymentsRetrieveRequest, PaymentData<F>>,
> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/operations/payment_status.rs | crate: router
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,
};
type PaymentStatusOperation<'b, F, R> = BoxedOperation<'b, F, R, PaymentData<F>>;
async fn guard_payment_against_blocklist<'a>(
&'a self,
_state: &SessionState,
_merchant_account: &domain::MerchantAccount,
_key_store: &domain::MerchantKeyStore,
_payment_data: &mut PaymentData<F>,
) -> CustomResult<bool, errors::ApiErrorResponse> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/operations/payment_status.rs | crate: router
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,
};
async fn get_connector<'a>(
&'a self,
_merchant_account: &domain::MerchantAccount,
state: &SessionState,
request: &api::PaymentsRequest,
_payment_intent: &storage::PaymentIntent,
_key_store: &domain::MerchantKeyStore,
) -> CustomResult<api::ConnectorChoice, errors::ApiErrorResponse> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/operations/payment_status.rs | crate: router
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,
};
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> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/operations/payment_status.rs | crate: router
use api_models::enums::FrmSuggestion;
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,
};
type PaymentStatusOperation<'b, F, R> = BoxedOperation<'b, F, R, PaymentData<F>>;
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>,
)> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/operations/payment_status.rs | crate: router
use api_models::enums::FrmSuggestion;
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,
};
type PaymentStatusOperation<'b, F, R> = BoxedOperation<'b, F, R, PaymentData<F>>;
async fn get_or_create_customer_details<'a>(
&'a self,
state: &SessionState,
payment_data: &mut PaymentData<F>,
request: Option<CustomerDetails>,
key_store: &domain::MerchantKeyStore,
storage_scheme: enums::MerchantStorageScheme,
) -> CustomResult<
(
PaymentStatusOperation<'a, F, api::PaymentsRequest>,
Option<domain::Customer>,
),
errors::StorageError,
> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/operations/payment_status.rs | crate: router
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,
};
type PaymentStatusOperation<'b, F, R> = BoxedOperation<'b, F, R, PaymentData<F>>;
fn to_update_tracker(
&self,
) -> RouterResult<&(dyn UpdateTracker<F, PaymentData<F>, api::PaymentsRequest> + Send + Sync)>
{
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/operations/payment_status.rs | crate: router
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,
};
type PaymentStatusOperation<'b, F, R> = BoxedOperation<'b, F, R, PaymentData<F>>;
fn to_domain(&self) -> RouterResult<&dyn Domain<F, api::PaymentsRequest, PaymentData<F>>> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/operations/payment_status.rs | crate: router
use api_models::enums::FrmSuggestion;
use common_utils::{ext_traits::AsyncExt, types::keymanager::KeyManagerState};
use error_stack::ResultExt;
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,
};
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,
_platform_merchant_account: Option<&domain::MerchantAccount>,
) -> RouterResult<(storage::PaymentIntent, storage::PaymentAttempt)> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/operations/payment_status.rs | crate: router
use std::marker::PhantomData;
use api_models::enums::FrmSuggestion;
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,
};
type PaymentStatusOperation<'b, F, R> = BoxedOperation<'b, F, R, PaymentData<F>>;
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,
merchant_account: &domain::MerchantAccount,
key_store: &domain::MerchantKeyStore,
state: &SessionState,
request: &api::PaymentsRetrieveRequest,
operation: Op,
storage_scheme: enums::MerchantStorageScheme,
platform_merchant_account: Option<&domain::MerchantAccount>,
) -> RouterResult<operations::GetTrackerResponse<'a, F, api::PaymentsRetrieveRequest, PaymentData<F>>>
{
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/operations/payment_get.rs | crate: router
use hyperswitch_domain_models::payments::PaymentStatusData;
use crate::{
core::{
errors::{self, CustomResult, RouterResult, StorageErrorExt},
payments::{
helpers,
operations::{self, ValidateStatusForOperation},
},
utils::ValidatePlatformMerchant,
},
routes::{app::ReqState, SessionState},
types::{
api::{self, ConnectorCallType},
domain::{self},
storage::{self, enums as storage_enums},
},
utils::OptionExt,
};
type BoxedConfirmOperation<'b, F> =
super::BoxedOperation<'b, F, PaymentsRetrieveRequest, PaymentStatusData<F>>;
async fn perform_routing<'a>(
&'a self,
_merchant_account: &domain::MerchantAccount,
_business_profile: &domain::Profile,
state: &SessionState,
// TODO: do not take the whole payment data here
payment_data: &mut PaymentStatusData<F>,
_mechant_key_store: &domain::MerchantKeyStore,
) -> CustomResult<ConnectorCallType, errors::ApiErrorResponse> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/operations/payment_get.rs | crate: router
use hyperswitch_domain_models::payments::PaymentStatusData;
use crate::{
core::{
errors::{self, CustomResult, RouterResult, StorageErrorExt},
payments::{
helpers,
operations::{self, ValidateStatusForOperation},
},
utils::ValidatePlatformMerchant,
},
routes::{app::ReqState, SessionState},
types::{
api::{self, ConnectorCallType},
domain::{self},
storage::{self, enums as storage_enums},
},
utils::OptionExt,
};
type BoxedConfirmOperation<'b, F> =
super::BoxedOperation<'b, F, PaymentsRetrieveRequest, PaymentStatusData<F>>;
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>
{
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/operations/payment_get.rs | crate: router
use api_models::{enums::FrmSuggestion, payments::PaymentsRetrieveRequest};
use hyperswitch_domain_models::payments::PaymentStatusData;
use crate::{
core::{
errors::{self, CustomResult, RouterResult, StorageErrorExt},
payments::{
helpers,
operations::{self, ValidateStatusForOperation},
},
utils::ValidatePlatformMerchant,
},
routes::{app::ReqState, SessionState},
types::{
api::{self, ConnectorCallType},
domain::{self},
storage::{self, enums as storage_enums},
},
utils::OptionExt,
};
type BoxedConfirmOperation<'b, F> =
super::BoxedOperation<'b, F, PaymentsRetrieveRequest, PaymentStatusData<F>>;
async fn update_trackers<'b>(
&'b self,
_state: &'b SessionState,
_req_state: ReqState,
payment_data: PaymentStatusData<F>,
_customer: Option<domain::Customer>,
_storage_scheme: storage_enums::MerchantStorageScheme,
_updated_customer: Option<storage::CustomerUpdate>,
_key_store: &domain::MerchantKeyStore,
_frm_suggestion: Option<FrmSuggestion>,
_header_payload: hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<(BoxedConfirmOperation<'b, F>, PaymentStatusData<F>)>
where
F: 'b + Send,
{
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/operations/payment_get.rs | crate: router
use hyperswitch_domain_models::payments::PaymentStatusData;
use crate::{
core::{
errors::{self, CustomResult, RouterResult, StorageErrorExt},
payments::{
helpers,
operations::{self, ValidateStatusForOperation},
},
utils::ValidatePlatformMerchant,
},
routes::{app::ReqState, SessionState},
types::{
api::{self, ConnectorCallType},
domain::{self},
storage::{self, enums as storage_enums},
},
utils::OptionExt,
};
type BoxedConfirmOperation<'b, F> =
super::BoxedOperation<'b, F, PaymentsRetrieveRequest, PaymentStatusData<F>>;
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>,
)> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/operations/payment_get.rs | crate: router
use api_models::{enums::FrmSuggestion, payments::PaymentsRetrieveRequest};
use crate::{
core::{
errors::{self, CustomResult, RouterResult, StorageErrorExt},
payments::{
helpers,
operations::{self, ValidateStatusForOperation},
},
utils::ValidatePlatformMerchant,
},
routes::{app::ReqState, SessionState},
types::{
api::{self, ConnectorCallType},
domain::{self},
storage::{self, enums as storage_enums},
},
utils::OptionExt,
};
type BoxedConfirmOperation<'b, F> =
super::BoxedOperation<'b, F, PaymentsRetrieveRequest, PaymentStatusData<F>>;
fn validate_request<'a, 'b>(
&'b self,
_request: &PaymentsRetrieveRequest,
merchant_account: &'a domain::MerchantAccount,
) -> RouterResult<operations::ValidateResult> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/operations/payment_get.rs | crate: router
use api_models::{enums::FrmSuggestion, payments::PaymentsRetrieveRequest};
use super::{Domain, GetTracker, Operation, UpdateTracker, ValidateRequest};
use crate::{
core::{
errors::{self, CustomResult, RouterResult, StorageErrorExt},
payments::{
helpers,
operations::{self, ValidateStatusForOperation},
},
utils::ValidatePlatformMerchant,
},
routes::{app::ReqState, SessionState},
types::{
api::{self, ConnectorCallType},
domain::{self},
storage::{self, enums as storage_enums},
},
utils::OptionExt,
};
type BoxedConfirmOperation<'b, F> =
super::BoxedOperation<'b, F, PaymentsRetrieveRequest, PaymentStatusData<F>>;
fn to_domain(&self) -> RouterResult<&dyn Domain<F, PaymentsRetrieveRequest, Self::Data>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/operations/payment_get.rs | crate: router
use api_models::{enums::FrmSuggestion, payments::PaymentsRetrieveRequest};
use super::{Domain, GetTracker, Operation, UpdateTracker, ValidateRequest};
use crate::{
core::{
errors::{self, CustomResult, RouterResult, StorageErrorExt},
payments::{
helpers,
operations::{self, ValidateStatusForOperation},
},
utils::ValidatePlatformMerchant,
},
routes::{app::ReqState, SessionState},
types::{
api::{self, ConnectorCallType},
domain::{self},
storage::{self, enums as storage_enums},
},
utils::OptionExt,
};
type BoxedConfirmOperation<'b, F> =
super::BoxedOperation<'b, F, PaymentsRetrieveRequest, PaymentStatusData<F>>;
fn to_get_tracker(
&self,
) -> RouterResult<&(dyn GetTracker<F, Self::Data, PaymentsRetrieveRequest> + Send + Sync)> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/operations/payment_get.rs | crate: router
use api_models::{enums::FrmSuggestion, payments::PaymentsRetrieveRequest};
use super::{Domain, GetTracker, Operation, UpdateTracker, ValidateRequest};
use crate::{
core::{
errors::{self, CustomResult, RouterResult, StorageErrorExt},
payments::{
helpers,
operations::{self, ValidateStatusForOperation},
},
utils::ValidatePlatformMerchant,
},
routes::{app::ReqState, SessionState},
types::{
api::{self, ConnectorCallType},
domain::{self},
storage::{self, enums as storage_enums},
},
utils::OptionExt,
};
type BoxedConfirmOperation<'b, F> =
super::BoxedOperation<'b, F, PaymentsRetrieveRequest, PaymentStatusData<F>>;
fn to_validate_request(
&self,
) -> RouterResult<&(dyn ValidateRequest<F, PaymentsRetrieveRequest, Self::Data> + Send + Sync)>
{
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/operations/payment_get.rs | crate: router
use api_models::{enums::FrmSuggestion, payments::PaymentsRetrieveRequest};
use super::{Domain, GetTracker, Operation, UpdateTracker, ValidateRequest};
use crate::{
core::{
errors::{self, CustomResult, RouterResult, StorageErrorExt},
payments::{
helpers,
operations::{self, ValidateStatusForOperation},
},
utils::ValidatePlatformMerchant,
},
routes::{app::ReqState, SessionState},
types::{
api::{self, ConnectorCallType},
domain::{self},
storage::{self, enums as storage_enums},
},
utils::OptionExt,
};
type BoxedConfirmOperation<'b, F> =
super::BoxedOperation<'b, F, PaymentsRetrieveRequest, PaymentStatusData<F>>;
fn to_update_tracker(
&self,
) -> RouterResult<&(dyn UpdateTracker<F, Self::Data, PaymentsRetrieveRequest> + Send + Sync)>
{
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/operations/payment_get.rs | crate: router
use crate::{
core::{
errors::{self, CustomResult, RouterResult, StorageErrorExt},
payments::{
helpers,
operations::{self, ValidateStatusForOperation},
},
utils::ValidatePlatformMerchant,
},
routes::{app::ReqState, SessionState},
types::{
api::{self, ConnectorCallType},
domain::{self},
storage::{self, enums as storage_enums},
},
utils::OptionExt,
};
/// 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> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/operations/payment_get.rs | crate: router
use api_models::{enums::FrmSuggestion, payments::PaymentsRetrieveRequest};
use common_utils::ext_traits::AsyncExt;
use hyperswitch_domain_models::payments::PaymentStatusData;
use crate::{
core::{
errors::{self, CustomResult, RouterResult, StorageErrorExt},
payments::{
helpers,
operations::{self, ValidateStatusForOperation},
},
utils::ValidatePlatformMerchant,
},
routes::{app::ReqState, SessionState},
types::{
api::{self, ConnectorCallType},
domain::{self},
storage::{self, enums as storage_enums},
},
utils::OptionExt,
};
type BoxedConfirmOperation<'b, F> =
super::BoxedOperation<'b, F, PaymentsRetrieveRequest, PaymentStatusData<F>>;
async fn get_trackers<'a>(
&'a self,
state: &'a SessionState,
payment_id: &common_utils::id_type::GlobalPaymentId,
request: &PaymentsRetrieveRequest,
merchant_account: &domain::MerchantAccount,
_profile: &domain::Profile,
key_store: &domain::MerchantKeyStore,
_header_payload: &hyperswitch_domain_models::payments::HeaderPayload,
platform_merchant_account: Option<&domain::MerchantAccount>,
) -> RouterResult<operations::GetTrackerResponse<PaymentStatusData<F>>> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/operations/payment_capture_v2.rs | crate: router
use api_models::{enums::FrmSuggestion, payments::PaymentsCaptureRequest};
use hyperswitch_domain_models::payments::PaymentCaptureData;
use crate::{
core::{
errors::{self, CustomResult, RouterResult, StorageErrorExt},
payments::{
helpers,
operations::{self, ValidateStatusForOperation},
},
utils::ValidatePlatformMerchant,
},
routes::{app::ReqState, SessionState},
types::{
api::{self, ConnectorCallType},
domain::{self},
storage::{self, enums as storage_enums},
},
utils::OptionExt,
};
type BoxedConfirmOperation<'b, F> =
super::BoxedOperation<'b, F, PaymentsCaptureRequest, PaymentCaptureData<F>>;
async fn update_trackers<'b>(
&'b self,
state: &'b SessionState,
_req_state: ReqState,
mut payment_data: PaymentCaptureData<F>,
_customer: Option<domain::Customer>,
storage_scheme: storage_enums::MerchantStorageScheme,
_updated_customer: Option<storage::CustomerUpdate>,
key_store: &domain::MerchantKeyStore,
_frm_suggestion: Option<FrmSuggestion>,
_header_payload: hyperswitch_domain_models::payments::HeaderPayload,
) -> RouterResult<(BoxedConfirmOperation<'b, F>, PaymentCaptureData<F>)>
where
F: 'b + Send,
{
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/operations/payment_capture_v2.rs | crate: router
use hyperswitch_domain_models::payments::PaymentCaptureData;
use crate::{
core::{
errors::{self, CustomResult, RouterResult, StorageErrorExt},
payments::{
helpers,
operations::{self, ValidateStatusForOperation},
},
utils::ValidatePlatformMerchant,
},
routes::{app::ReqState, SessionState},
types::{
api::{self, ConnectorCallType},
domain::{self},
storage::{self, enums as storage_enums},
},
utils::OptionExt,
};
type BoxedConfirmOperation<'b, F> =
super::BoxedOperation<'b, F, PaymentsCaptureRequest, PaymentCaptureData<F>>;
async fn perform_routing<'a>(
&'a self,
_merchant_account: &domain::MerchantAccount,
_business_profile: &domain::Profile,
state: &SessionState,
// TODO: do not take the whole payment data here
payment_data: &mut PaymentCaptureData<F>,
_mechant_key_store: &domain::MerchantKeyStore,
) -> CustomResult<ConnectorCallType, errors::ApiErrorResponse> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/operations/payment_capture_v2.rs | crate: router
use hyperswitch_domain_models::payments::PaymentCaptureData;
use crate::{
core::{
errors::{self, CustomResult, RouterResult, StorageErrorExt},
payments::{
helpers,
operations::{self, ValidateStatusForOperation},
},
utils::ValidatePlatformMerchant,
},
routes::{app::ReqState, SessionState},
types::{
api::{self, ConnectorCallType},
domain::{self},
storage::{self, enums as storage_enums},
},
utils::OptionExt,
};
type BoxedConfirmOperation<'b, F> =
super::BoxedOperation<'b, F, PaymentsCaptureRequest, PaymentCaptureData<F>>;
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>
{
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/operations/payment_capture_v2.rs | crate: router
use api_models::{enums::FrmSuggestion, payments::PaymentsCaptureRequest};
use hyperswitch_domain_models::payments::PaymentCaptureData;
use crate::{
core::{
errors::{self, CustomResult, RouterResult, StorageErrorExt},
payments::{
helpers,
operations::{self, ValidateStatusForOperation},
},
utils::ValidatePlatformMerchant,
},
routes::{app::ReqState, SessionState},
types::{
api::{self, ConnectorCallType},
domain::{self},
storage::{self, enums as storage_enums},
},
utils::OptionExt,
};
type BoxedConfirmOperation<'b, F> =
super::BoxedOperation<'b, F, PaymentsCaptureRequest, PaymentCaptureData<F>>;
async fn get_trackers<'a>(
&'a self,
state: &'a SessionState,
payment_id: &common_utils::id_type::GlobalPaymentId,
request: &PaymentsCaptureRequest,
merchant_account: &domain::MerchantAccount,
_profile: &domain::Profile,
key_store: &domain::MerchantKeyStore,
_header_payload: &hyperswitch_domain_models::payments::HeaderPayload,
platform_merchant_account: Option<&domain::MerchantAccount>,
) -> RouterResult<operations::GetTrackerResponse<PaymentCaptureData<F>>> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/router/src/core/payments/operations/payment_capture_v2.rs | crate: router
use crate::{
core::{
errors::{self, CustomResult, RouterResult, StorageErrorExt},
payments::{
helpers,
operations::{self, ValidateStatusForOperation},
},
utils::ValidatePlatformMerchant,
},
routes::{app::ReqState, SessionState},
types::{
api::{self, ConnectorCallType},
domain::{self},
storage::{self, enums as storage_enums},
},
utils::OptionExt,
};
/// 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::PartiallyCapturedAndCapturable => Ok(()),
common_enums::IntentStatus::Succeeded
| common_enums::IntentStatus::Failed
| common_enums::IntentStatus::Cancelled
| common_enums::IntentStatus::Processing
| common_enums::IntentStatus::RequiresCustomerAction
| common_enums::IntentStatus::RequiresMerchantAction
| common_enums::IntentStatus::RequiresPaymentMethod
| common_enums::IntentStatus::PartiallyCaptured
| common_enums::IntentStatus::RequiresConfirmation => {
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(", "),
})
}
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/operations/payment_capture_v2.rs | crate: router
use hyperswitch_domain_models::payments::PaymentCaptureData;
use crate::{
core::{
errors::{self, CustomResult, RouterResult, StorageErrorExt},
payments::{
helpers,
operations::{self, ValidateStatusForOperation},
},
utils::ValidatePlatformMerchant,
},
routes::{app::ReqState, SessionState},
types::{
api::{self, ConnectorCallType},
domain::{self},
storage::{self, enums as storage_enums},
},
utils::OptionExt,
};
type BoxedConfirmOperation<'b, F> =
super::BoxedOperation<'b, F, PaymentsCaptureRequest, PaymentCaptureData<F>>;
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>,
)> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/core/payments/operations/payment_capture_v2.rs | crate: router
use api_models::{enums::FrmSuggestion, payments::PaymentsCaptureRequest};
use crate::{
core::{
errors::{self, CustomResult, RouterResult, StorageErrorExt},
payments::{
helpers,
operations::{self, ValidateStatusForOperation},
},
utils::ValidatePlatformMerchant,
},
routes::{app::ReqState, SessionState},
types::{
api::{self, ConnectorCallType},
domain::{self},
storage::{self, enums as storage_enums},
},
utils::OptionExt,
};
type BoxedConfirmOperation<'b, F> =
super::BoxedOperation<'b, F, PaymentsCaptureRequest, PaymentCaptureData<F>>;
fn validate_request<'a, 'b>(
&'b self,
_request: &PaymentsCaptureRequest,
merchant_account: &'a domain::MerchantAccount,
) -> RouterResult<operations::ValidateResult> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.