text stringlengths 70 351k | source stringclasses 4
values |
|---|---|
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/stax.rs | crate: router | connector: stax
use router::types::{self, domain, storage::enums, PaymentsResponseData};
fn customer_details() -> Option<types::ConnectorCustomerData> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/stax.rs | crate: router | connector: stax | op: capture
use router::types::{self, domain, storage::enums, PaymentsResponseData};
async fn should_fail_void_payment_for_auto_capture() {
let authorize_response = CONNECTOR
.make_payment(
payment_method_details(),
get_default_payment_info(None, create_customer_and_get_token().await),
)
.await
.unwrap();
assert_eq!(authorize_response.status, enums::AttemptStatus::Charged);
let txn_id = utils::get_connector_transaction_id(authorize_response.response);
assert_ne!(txn_id, None, "Empty connector transaction id");
let void_response = CONNECTOR
.void_payment(txn_id.unwrap(), None, get_default_payment_info(None, None))
.await
.unwrap();
assert_eq!(
void_response.response.unwrap_err().message,
"You cannot cancel this PaymentIntent because it has a status of succeeded."
);
} | ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/stax.rs | crate: router | connector: stax | op: capture
use router::types::{self, domain, storage::enums, PaymentsResponseData};
async fn should_refund_auto_captured_payment() {
let response = CONNECTOR
.make_payment_and_refund(
payment_method_details(),
None,
get_default_payment_info(None, create_customer_and_get_token().await),
)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/stax.rs | crate: router | connector: stax
use router::types::{self, domain, storage::enums, PaymentsResponseData};
async fn create_customer_and_get_token() -> Option<String> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/stax.rs | crate: router | connector: stax
use masking::Secret;
use router::types::{self, domain, storage::enums, PaymentsResponseData};
fn token_details() -> Option<types::PaymentMethodTokenizationData> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/stax.rs | crate: router | connector: stax
use router::types::{self, domain, storage::enums, PaymentsResponseData};
fn customer_details() -> Option<types::ConnectorCustomerData> {
Some(types::ConnectorCustomerData {
..utils::CustomerType::default().0
})
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/stax.rs | crate: router | connector: stax
fn get_default_payment_info(
connector_customer: Option<String>,
payment_method_token: Option<String>,
) -> Option<utils::PaymentInfo> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/nuvei.rs | crate: router | connector: nuvei | op: refund
use router::types::{self, storage::enums};
async fn should_accept_refund_amount_higher_than_payment_amount() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/nuvei.rs | crate: router | connector: nuvei | op: refund
use router::types::{self, storage::enums};
async fn should_accept_refund_amount_higher_than_payment_amount() {
let response = CONNECTOR
.make_payment_and_refund(
get_payment_data(),
Some(types::RefundsData {
refund_amount: 150,
..utils::PaymentRefundType::default().0
}),
None,
)
.await
.unwrap();
assert_eq!(
response.response.unwrap().refund_status,
enums::RefundStatus::Success,
);
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/nuvei.rs | crate: router | connector: nuvei
use masking::Secret;
use router::types::{self, storage::enums};
async fn should_succeed_payment_for_incorrect_expiry_year() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/nuvei.rs | crate: router | connector: nuvei
use router::types::{self, storage::enums};
async fn should_fail_payment_for_incorrect_card_number() {
let response = CONNECTOR
.make_payment(
Some(types::PaymentsAuthorizeData {
payment_method_data: types::domain::PaymentMethodData::Card(types::domain::Card {
card_number: cards::CardNumber::from_str("1234567891011").unwrap(),
..utils::CCardType::default().0
}),
..utils::PaymentAuthorizeType::default().0
}),
None,
)
.await
.unwrap();
assert_eq!(
response.response.unwrap_err().message,
"Missing or invalid CardData data. Invalid credit card number.".to_string(),
);
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/worldline.rs | crate: router | connector: worldline | op: sync
use router::{
connector::Worldline,
core::errors,
types::{self, storage::enums, PaymentAddress},
};
async fn should_sync_auto_auth_payment() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/worldline.rs | crate: router | connector: worldline | op: sync
use router::{
connector::Worldline,
core::errors,
types::{self, storage::enums, PaymentAddress},
};
async fn should_sync_manual_auth_payment() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/worldline.rs | crate: router | connector: worldline | op: authorize
use masking::Secret;
use router::{
connector::Worldline,
core::errors,
types::{self, storage::enums, PaymentAddress},
};
fn get_payment_authorize_data(
card_number: &str,
card_exp_month: &str,
card_exp_year: &str,
card_cvc: &str,
capture_method: enums::CaptureMethod,
) -> Option<types::PaymentsAuthorizeData> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/worldline.rs | crate: router | connector: worldline | op: authorize
use router::{
connector::Worldline,
core::errors,
types::{self, storage::enums, PaymentAddress},
};
async fn should_auto_authorize_and_request_capture() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/worldline.rs | crate: router | connector: worldline | op: refund
use router::{
connector::Worldline,
core::errors,
types::{self, storage::enums, PaymentAddress},
};
async fn should_fail_refund_with_invalid_payment_status() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/worldline.rs | crate: router | connector: worldline | op: cancel
async fn should_fail_cancel_with_invalid_payment_id() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/worldline.rs | crate: router | connector: worldline | op: capture
use router::{
connector::Worldline,
core::errors,
types::{self, storage::enums, PaymentAddress},
};
async fn should_cancel_uncaptured_payment() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/worldline.rs | crate: router | connector: worldline | op: authorize
use router::{
connector::Worldline,
core::errors,
types::{self, storage::enums, PaymentAddress},
};
async fn should_cancel_unauthorized_payment() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/worldline.rs | crate: router | connector: worldline | op: capture
async fn should_fail_capture_payment() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/worldline.rs | crate: router | connector: worldline
use router::{
connector::Worldline,
core::errors,
types::{self, storage::enums, PaymentAddress},
};
async fn should_fail_payment_for_invalid_cvc() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/worldline.rs | crate: router | connector: worldline
use router::{
connector::Worldline,
core::errors,
types::{self, storage::enums, PaymentAddress},
};
async fn should_throw_missing_required_field_for_country() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/worldline.rs | crate: router | connector: worldline | op: authorize
use router::{
connector::Worldline,
core::errors,
types::{self, storage::enums, PaymentAddress},
};
async fn should_auto_authorize_and_request_capture() {
let authorize_data = WorldlineTest::get_payment_authorize_data(
"4012000033330026",
"10",
"2025",
"123",
enums::CaptureMethod::Automatic,
);
let response = WorldlineTest {}
.make_payment(authorize_data, WorldlineTest::get_payment_info())
.await
.unwrap();
assert_eq!(response.status, enums::AttemptStatus::Pending);
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/worldline.rs | crate: router | connector: worldline
use router::{
connector::Worldline,
core::errors,
types::{self, storage::enums, PaymentAddress},
};
async fn should_requires_manual_authorization() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/opennode.rs | crate: router | connector: opennode | op: authorize
use router::types::{self, api, domain, storage::enums};
async fn should_only_authorize_payment() {
{
types::PaymentsResponseData::TransactionResponse {
redirection_data, ..
} => Some(redirection_data),<|fim_suffix|>
<|fim_middle|>
_ => None,
}
} | ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/opennode.rs | crate: router | connector: opennode | op: authorize
use router::types::{self, api, domain, storage::enums};
async fn should_sync_authorized_payment() {
let response = CONNECTOR
.psync_retry_till_status_matches(
enums::AttemptStatus::Authorized,
Some(types::PaymentsSyncData {
connector_transaction_id: types::ResponseId::ConnectorTransactionId(
"5adebfb1-802e-432b-8b42-5db4b754b2eb".to_string(),
),
..Default::default()
}),
get_default_payment_info(),
)
.await
.expect("PSync response");
assert_eq!(response.status, enums::AttemptStatus::Charged);
} | ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/opennode.rs | crate: router | connector: opennode
use masking::Secret;
use router::types::{self, api, domain, storage::enums};
use crate::{
connector_auth,
utils::{self, ConnectorActions},
};
fn get_data(&self) -> api::ConnectorData {
use router::connector::Opennode;
utils::construct_connector_data_old(
Box::new(&Opennode),
types::Connector::Opennode,
api::GetToken::Connector,
None,
)
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/aci.rs | crate: router | connector: aci | op: refund
use std::{borrow::Cow, marker::PhantomData, str::FromStr, sync::Arc};
use common_utils::id_type;
use masking::Secret;
use router::{
configs::settings::Settings,
core::payments,
db::StorageImpl,
routes, services,
types::{self, storage::enums, PaymentAddress},
};
use tokio::sync::oneshot;
use crate::{connector_auth::ConnectorAuthentication, utils};
async fn refunds_create_failure() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/aci.rs | crate: router | connector: aci | op: refund
use std::{borrow::Cow, marker::PhantomData, str::FromStr, sync::Arc};
use common_utils::id_type;
use masking::Secret;
use router::{
configs::settings::Settings,
core::payments,
db::StorageImpl,
routes, services,
types::{self, storage::enums, PaymentAddress},
};
use tokio::sync::oneshot;
use crate::{connector_auth::ConnectorAuthentication, utils};
async fn refund_for_successful_payments() {
{
types::PaymentsResponseData::TransactionResponse { resource_id, .. } => {
resource_id.get_connector_transaction_id().unwrap()
}<|fim_suffix|>
<|fim_middle|>
_ => panic!("Connector transaction id not found"),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/aci.rs | crate: router | connector: aci
use std::{borrow::Cow, marker::PhantomData, str::FromStr, sync::Arc};
use common_utils::id_type;
use masking::Secret;
use router::{
configs::settings::Settings,
core::payments,
db::StorageImpl,
routes, services,
types::{self, storage::enums, PaymentAddress},
};
use tokio::sync::oneshot;
use crate::{connector_auth::ConnectorAuthentication, utils};
async fn payments_create_failure() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/aci.rs | crate: router | connector: aci
use std::{borrow::Cow, marker::PhantomData, str::FromStr, sync::Arc};
use common_utils::id_type;
use masking::Secret;
use router::{
configs::settings::Settings,
core::payments,
db::StorageImpl,
routes, services,
types::{self, storage::enums, PaymentAddress},
};
use tokio::sync::oneshot;
use crate::{connector_auth::ConnectorAuthentication, utils};
async fn payments_create_success() {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/aci.rs | crate: router | connector: aci | op: refund
use std::{borrow::Cow, marker::PhantomData, str::FromStr, sync::Arc};
use router::{
configs::settings::Settings,
core::payments,
db::StorageImpl,
routes, services,
types::{self, storage::enums, PaymentAddress},
};
use crate::{connector_auth::ConnectorAuthentication, utils};
fn construct_refund_router_data<F>() -> types::RefundsRouterData<F> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/aci.rs | crate: router | connector: aci | op: refund
use std::{borrow::Cow, marker::PhantomData, str::FromStr, sync::Arc};
use common_utils::id_type;
use masking::Secret;
use router::{
configs::settings::Settings,
core::payments,
db::StorageImpl,
routes, services,
types::{self, storage::enums, PaymentAddress},
};
use tokio::sync::oneshot;
use crate::{connector_auth::ConnectorAuthentication, utils};
async fn refund_for_successful_payments() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/aci.rs | crate: router | connector: aci
use std::{borrow::Cow, marker::PhantomData, str::FromStr, sync::Arc};
use hyperswitch_domain_models::address::{Address, AddressDetails, PhoneDetails};
use masking::Secret;
use router::{
configs::settings::Settings,
core::payments,
db::StorageImpl,
routes, services,
types::{self, storage::enums, PaymentAddress},
};
use crate::{connector_auth::ConnectorAuthentication, utils};
fn construct_payment_router_data() -> types::PaymentsAuthorizeRouterData {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/iatapay.rs | crate: router | connector: iatapay
use router::types::{self, api, storage::enums, AccessToken};
fn get_access_token() -> Option<AccessToken> {
{
types::ConnectorAuthType::SignatureKey {
api_key,
key1: _,
api_secret: _,
} => Some(AccessToken {
token: api_key,
expires: 60 * 5,
}),<|fim_suffix|>
<|fim_middle|>
_ => None,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/iatapay.rs | crate: router | connector: iatapay | op: refund
use router::types::{self, api, storage::enums, AccessToken};
use crate::{
connector_auth,
utils::{
self, get_connector_transaction_id, Connector, ConnectorActions, PaymentAuthorizeType,
},
};
async fn should_fail_for_refund_on_unsuccessed_payment() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/iatapay.rs | crate: router | connector: iatapay
use router::types::{self, api, storage::enums, AccessToken};
async fn should_only_create_payment() {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/utils.rs | crate: router | connector: utils
use router::{
configs::settings::Settings,
core::{errors::ConnectorError, payments},
db::StorageImpl,
routes,
services::{
self,
connector_integration_interface::{BoxedConnectorIntegrationInterface, ConnectorEnum},
},
types::{self, storage::enums, AccessToken, MinorUnit, PaymentAddress, RouterData},
};
pub fn to_connector_auth_type(auth_type: ConnectorAuthType) -> types::ConnectorAuthType {
match auth_type {
ConnectorAuthType::HeaderKey { api_key } => types::ConnectorAuthType::HeaderKey { api_key },
ConnectorAuthType::BodyKey { api_key, key1 } => {
types::ConnectorAuthType::BodyKey { api_key, key1 }
}
ConnectorAuthType::SignatureKey {
api_key,
key1,
api_secret,
} => types::ConnectorAuthType::SignatureKey {
api_key,
key1,
api_secret,
},
ConnectorAuthType::MultiAuthKey {
api_key,
key1,
api_secret,
key2,
} => types::ConnectorAuthType::MultiAuthKey {
api_key,
key1,
api_secret,
key2,
},
_ => types::ConnectorAuthType::NoKey,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/utils.rs | crate: router | connector: utils
use std::{fmt::Debug, marker::PhantomData, str::FromStr, sync::Arc, time::Duration};
use error_stack::Report;
use router::{
configs::settings::Settings,
core::{errors::ConnectorError, payments},
db::StorageImpl,
routes,
services::{
self,
connector_integration_interface::{BoxedConnectorIntegrationInterface, ConnectorEnum},
},
types::{self, storage::enums, AccessToken, MinorUnit, PaymentAddress, RouterData},
};
async fn call_connector<
T: Debug + Clone + 'static,
ResourceCommonData: Debug
+ Clone
+ services::connector_integration_interface::RouterDataConversion<T, Req, Resp>
+ 'static,
Req: Debug + Clone + 'static,
Resp: Debug + Clone + 'static,
>(
request: RouterData<T, Req, Resp>,
integration: BoxedConnectorIntegrationInterface<T, ResourceCommonData, Req, Resp>,
) -> Result<RouterData<T, Req, Resp>, Report<ConnectorError>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/utils.rs | crate: router | connector: utils | op: payout
use error_stack::Report;
use router::{
configs::settings::Settings,
core::{errors::ConnectorError, payments},
db::StorageImpl,
routes,
services::{
self,
connector_integration_interface::{BoxedConnectorIntegrationInterface, ConnectorEnum},
},
types::{self, storage::enums, AccessToken, MinorUnit, PaymentAddress, RouterData},
};
async fn create_payout_recipient(
&self,
payout_type: enums::PayoutType,
payment_info: Option<PaymentInfo>,
) -> Result<types::PayoutsResponseData, Report<ConnectorError>> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/utils.rs | crate: router | connector: utils | op: cancel
use error_stack::Report;
use router::{
configs::settings::Settings,
core::{errors::ConnectorError, payments},
db::StorageImpl,
routes,
services::{
self,
connector_integration_interface::{BoxedConnectorIntegrationInterface, ConnectorEnum},
},
types::{self, storage::enums, AccessToken, MinorUnit, PaymentAddress, RouterData},
};
async fn create_and_cancel_payout(
&self,
connector_customer: Option<String>,
payout_type: enums::PayoutType,
payment_info: Option<PaymentInfo>,
) -> Result<types::PayoutsResponseData, Report<ConnectorError>> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/utils.rs | crate: router | connector: utils | op: cancel
use error_stack::Report;
use router::{
configs::settings::Settings,
core::{errors::ConnectorError, payments},
db::StorageImpl,
routes,
services::{
self,
connector_integration_interface::{BoxedConnectorIntegrationInterface, ConnectorEnum},
},
types::{self, storage::enums, AccessToken, MinorUnit, PaymentAddress, RouterData},
};
async fn cancel_payout(
&self,
connector_payout_id: String,
payout_type: enums::PayoutType,
payment_info: Option<PaymentInfo>,
) -> Result<types::PayoutsResponseData, Report<ConnectorError>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/utils.rs | crate: router | connector: utils | op: payout
use error_stack::Report;
use router::{
configs::settings::Settings,
core::{errors::ConnectorError, payments},
db::StorageImpl,
routes,
services::{
self,
connector_integration_interface::{BoxedConnectorIntegrationInterface, ConnectorEnum},
},
types::{self, storage::enums, AccessToken, MinorUnit, PaymentAddress, RouterData},
};
async fn create_payout(
&self,
connector_customer: Option<String>,
payout_type: enums::PayoutType,
payment_info: Option<PaymentInfo>,
) -> Result<types::PayoutsResponseData, Report<ConnectorError>> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/utils.rs | crate: router | connector: utils | op: payout
use error_stack::Report;
use router::{
configs::settings::Settings,
core::{errors::ConnectorError, payments},
db::StorageImpl,
routes,
services::{
self,
connector_integration_interface::{BoxedConnectorIntegrationInterface, ConnectorEnum},
},
types::{self, storage::enums, AccessToken, MinorUnit, PaymentAddress, RouterData},
};
async fn fulfill_payout(
&self,
connector_payout_id: Option<String>,
payout_type: enums::PayoutType,
payment_info: Option<PaymentInfo>,
) -> Result<types::PayoutsResponseData, Report<ConnectorError>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/utils.rs | crate: router | connector: utils | op: verify
use error_stack::Report;
use router::{
configs::settings::Settings,
core::{errors::ConnectorError, payments},
db::StorageImpl,
routes,
services::{
self,
connector_integration_interface::{BoxedConnectorIntegrationInterface, ConnectorEnum},
},
types::{self, storage::enums, AccessToken, MinorUnit, PaymentAddress, RouterData},
};
async fn verify_payout_eligibility(
&self,
payout_type: enums::PayoutType,
payment_info: Option<PaymentInfo>,
) -> Result<types::PayoutsResponseData, Report<ConnectorError>> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/utils.rs | crate: router | connector: utils
use std::{fmt::Debug, marker::PhantomData, str::FromStr, sync::Arc, time::Duration};
use masking::Secret;
use router::{
configs::settings::Settings,
core::{errors::ConnectorError, payments},
db::StorageImpl,
routes,
services::{
self,
connector_integration_interface::{BoxedConnectorIntegrationInterface, ConnectorEnum},
},
types::{self, storage::enums, AccessToken, MinorUnit, PaymentAddress, RouterData},
};
fn generate_data<Flow, Req: From<Req>, Res>(
&self,
req: Req,
info: Option<PaymentInfo>,
) -> RouterData<Flow, Req, Res> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/utils.rs | crate: router | connector: utils | op: payout
use common_utils::pii::Email;
use masking::Secret;
use router::{
configs::settings::Settings,
core::{errors::ConnectorError, payments},
db::StorageImpl,
routes,
services::{
self,
connector_integration_interface::{BoxedConnectorIntegrationInterface, ConnectorEnum},
},
types::{self, storage::enums, AccessToken, MinorUnit, PaymentAddress, RouterData},
};
fn get_payout_request<Flow, Res>(
&self,
connector_payout_id: Option<String>,
payout_type: enums::PayoutType,
payment_info: Option<PaymentInfo>,
) -> RouterData<Flow, types::PayoutsData, Res> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/utils.rs | crate: router | connector: utils | op: sync
use std::{fmt::Debug, marker::PhantomData, str::FromStr, sync::Arc, time::Duration};
use error_stack::Report;
use router::{
configs::settings::Settings,
core::{errors::ConnectorError, payments},
db::StorageImpl,
routes,
services::{
self,
connector_integration_interface::{BoxedConnectorIntegrationInterface, ConnectorEnum},
},
types::{self, storage::enums, AccessToken, MinorUnit, PaymentAddress, RouterData},
};
/// will retry the rsync till the given status matches or retry max 3 times
async fn rsync_retry_till_status_matches(
&self,
status: enums::RefundStatus,
refund_id: String,
payment_data: Option<types::RefundsData>,
payment_info: Option<PaymentInfo>,
) -> Result<types::RefundSyncRouterData, Report<ConnectorError>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/utils.rs | crate: router | connector: utils | op: refund
use error_stack::Report;
use router::{
configs::settings::Settings,
core::{errors::ConnectorError, payments},
db::StorageImpl,
routes,
services::{
self,
connector_integration_interface::{BoxedConnectorIntegrationInterface, ConnectorEnum},
},
types::{self, storage::enums, AccessToken, MinorUnit, PaymentAddress, RouterData},
};
async fn sync_refund(
&self,
refund_id: String,
payment_data: Option<types::RefundsData>,
payment_info: Option<PaymentInfo>,
) -> Result<types::RefundSyncRouterData, Report<ConnectorError>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/utils.rs | crate: router | connector: utils | op: refund
use std::{fmt::Debug, marker::PhantomData, str::FromStr, sync::Arc, time::Duration};
use router::{
configs::settings::Settings,
core::{errors::ConnectorError, payments},
db::StorageImpl,
routes,
services::{
self,
connector_integration_interface::{BoxedConnectorIntegrationInterface, ConnectorEnum},
},
types::{self, storage::enums, AccessToken, MinorUnit, PaymentAddress, RouterData},
};
async fn make_payment_and_multiple_refund(
&self,
authorize_data: Option<types::PaymentsAuthorizeData>,
refund_data: Option<types::RefundsData>,
payment_info: Option<PaymentInfo>,
) {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/utils.rs | crate: router | connector: utils
use router::{
configs::settings::Settings,
core::{errors::ConnectorError, payments},
db::StorageImpl,
routes,
services::{
self,
connector_integration_interface::{BoxedConnectorIntegrationInterface, ConnectorEnum},
},
types::{self, storage::enums, AccessToken, MinorUnit, PaymentAddress, RouterData},
};
pub fn to_connector_auth_type(auth_type: ConnectorAuthType) -> types::ConnectorAuthType {
{
ConnectorAuthType::HeaderKey { api_key } => types::ConnectorAuthType::HeaderKey { api_key },<|fim_suffix|>
<|fim_middle|>
_ => types::ConnectorAuthType::NoKey,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/utils.rs | crate: router | connector: utils
use router::{
configs::settings::Settings,
core::{errors::ConnectorError, payments},
db::StorageImpl,
routes,
services::{
self,
connector_integration_interface::{BoxedConnectorIntegrationInterface, ConnectorEnum},
},
types::{self, storage::enums, AccessToken, MinorUnit, PaymentAddress, RouterData},
};
pub fn get_connector_transaction_id(
response: Result<types::PaymentsResponseData, types::ErrorResponse>,
) -> Option<String> {
{
Ok(types::PaymentsResponseData::TransactionResponse { resource_id, .. }) => {
resource_id.get_connector_transaction_id().ok()
}<|fim_suffix|>
<|fim_middle|>
Err(_) => None,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/utils.rs | crate: router | connector: utils | op: capture
use router::{
configs::settings::Settings,
core::{errors::ConnectorError, payments},
db::StorageImpl,
routes,
services::{
self,
connector_integration_interface::{BoxedConnectorIntegrationInterface, ConnectorEnum},
},
types::{self, storage::enums, AccessToken, MinorUnit, PaymentAddress, RouterData},
};
fn get_connector_transaction_id_from_capture_data(
&self,
response: types::PaymentsCaptureRouterData,
) -> Option<String> {
{
Ok(types::PaymentsResponseData::TransactionResponse { resource_id, .. }) => {
resource_id.get_connector_transaction_id().ok()
}<|fim_suffix|>
<|fim_middle|>
Err(_) => None,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/utils.rs | crate: router | connector: utils | op: sync
use error_stack::Report;
use router::{
configs::settings::Settings,
core::{errors::ConnectorError, payments},
db::StorageImpl,
routes,
services::{
self,
connector_integration_interface::{BoxedConnectorIntegrationInterface, ConnectorEnum},
},
types::{self, storage::enums, AccessToken, MinorUnit, PaymentAddress, RouterData},
};
async fn sync_payment(
&self,
payment_data: Option<types::PaymentsSyncData>,
payment_info: Option<PaymentInfo>,
) -> Result<types::PaymentsSyncRouterData, Report<ConnectorError>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/utils.rs | crate: router | connector: utils
use router::{
configs::settings::Settings,
core::{errors::ConnectorError, payments},
db::StorageImpl,
routes,
services::{
self,
connector_integration_interface::{BoxedConnectorIntegrationInterface, ConnectorEnum},
},
types::{self, storage::enums, AccessToken, MinorUnit, PaymentAddress, RouterData},
};
pub fn get_connector_metadata(
response: Result<types::PaymentsResponseData, types::ErrorResponse>,
) -> Option<serde_json::Value> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/utils.rs | crate: router | connector: utils
use router::{
configs::settings::Settings,
core::{errors::ConnectorError, payments},
db::StorageImpl,
routes,
services::{
self,
connector_integration_interface::{BoxedConnectorIntegrationInterface, ConnectorEnum},
},
types::{self, storage::enums, AccessToken, MinorUnit, PaymentAddress, RouterData},
};
pub fn get_connector_transaction_id(
response: Result<types::PaymentsResponseData, types::ErrorResponse>,
) -> Option<String> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/utils.rs | crate: router | connector: utils
use router::{
configs::settings::Settings,
core::{errors::ConnectorError, payments},
db::StorageImpl,
routes,
services::{
self,
connector_integration_interface::{BoxedConnectorIntegrationInterface, ConnectorEnum},
},
types::{self, storage::enums, AccessToken, MinorUnit, PaymentAddress, RouterData},
};
async fn start_server(&self, config: MockConfig) -> MockServer {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/utils.rs | crate: router | connector: utils | op: payout
use error_stack::Report;
use router::{
configs::settings::Settings,
core::{errors::ConnectorError, payments},
db::StorageImpl,
routes,
services::{
self,
connector_integration_interface::{BoxedConnectorIntegrationInterface, ConnectorEnum},
},
types::{self, storage::enums, AccessToken, MinorUnit, PaymentAddress, RouterData},
};
async fn create_and_fulfill_payout(
&self,
connector_customer: Option<String>,
payout_type: enums::PayoutType,
payment_info: Option<PaymentInfo>,
) -> Result<types::PayoutsResponseData, Report<ConnectorError>> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/utils.rs | crate: router | connector: utils | op: capture
use router::{
configs::settings::Settings,
core::{errors::ConnectorError, payments},
db::StorageImpl,
routes,
services::{
self,
connector_integration_interface::{BoxedConnectorIntegrationInterface, ConnectorEnum},
},
types::{self, storage::enums, AccessToken, MinorUnit, PaymentAddress, RouterData},
};
fn get_connector_transaction_id_from_capture_data(
&self,
response: types::PaymentsCaptureRouterData,
) -> Option<String> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/utils.rs | crate: router | connector: utils | op: capture
use std::{fmt::Debug, marker::PhantomData, str::FromStr, sync::Arc, time::Duration};
use error_stack::Report;
use router::{
configs::settings::Settings,
core::{errors::ConnectorError, payments},
db::StorageImpl,
routes,
services::{
self,
connector_integration_interface::{BoxedConnectorIntegrationInterface, ConnectorEnum},
},
types::{self, storage::enums, AccessToken, MinorUnit, PaymentAddress, RouterData},
};
async fn auth_capture_and_refund(
&self,
authorize_data: Option<types::PaymentsAuthorizeData>,
refund_data: Option<types::RefundsData>,
payment_info: Option<PaymentInfo>,
) -> Result<types::RefundExecuteRouterData, Report<ConnectorError>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/utils.rs | crate: router | connector: utils | op: refund
use std::{fmt::Debug, marker::PhantomData, str::FromStr, sync::Arc, time::Duration};
use error_stack::Report;
use router::{
configs::settings::Settings,
core::{errors::ConnectorError, payments},
db::StorageImpl,
routes,
services::{
self,
connector_integration_interface::{BoxedConnectorIntegrationInterface, ConnectorEnum},
},
types::{self, storage::enums, AccessToken, MinorUnit, PaymentAddress, RouterData},
};
async fn make_payment_and_refund(
&self,
authorize_data: Option<types::PaymentsAuthorizeData>,
refund_data: Option<types::RefundsData>,
payment_info: Option<PaymentInfo>,
) -> Result<types::RefundExecuteRouterData, Report<ConnectorError>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/utils.rs | crate: router | connector: utils | op: capture
use std::{fmt::Debug, marker::PhantomData, str::FromStr, sync::Arc, time::Duration};
use error_stack::Report;
use router::{
configs::settings::Settings,
core::{errors::ConnectorError, payments},
db::StorageImpl,
routes,
services::{
self,
connector_integration_interface::{BoxedConnectorIntegrationInterface, ConnectorEnum},
},
types::{self, storage::enums, AccessToken, MinorUnit, PaymentAddress, RouterData},
};
async fn capture_payment_and_refund(
&self,
authorize_data: Option<types::PaymentsAuthorizeData>,
capture_data: Option<types::PaymentsCaptureData>,
refund_data: Option<types::RefundsData>,
payment_info: Option<PaymentInfo>,
) -> Result<types::RefundExecuteRouterData, Report<ConnectorError>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/utils.rs | crate: router | connector: utils | op: refund
use error_stack::Report;
use router::{
configs::settings::Settings,
core::{errors::ConnectorError, payments},
db::StorageImpl,
routes,
services::{
self,
connector_integration_interface::{BoxedConnectorIntegrationInterface, ConnectorEnum},
},
types::{self, storage::enums, AccessToken, MinorUnit, PaymentAddress, RouterData},
};
async fn refund_payment(
&self,
transaction_id: String,
refund_data: Option<types::RefundsData>,
payment_info: Option<PaymentInfo>,
) -> Result<types::RefundExecuteRouterData, Report<ConnectorError>> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/utils.rs | crate: router | connector: utils | op: authorize
use std::{fmt::Debug, marker::PhantomData, str::FromStr, sync::Arc, time::Duration};
use error_stack::Report;
use router::{
configs::settings::Settings,
core::{errors::ConnectorError, payments},
db::StorageImpl,
routes,
services::{
self,
connector_integration_interface::{BoxedConnectorIntegrationInterface, ConnectorEnum},
},
types::{self, storage::enums, AccessToken, MinorUnit, PaymentAddress, RouterData},
};
async fn authorize_and_void_payment(
&self,
authorize_data: Option<types::PaymentsAuthorizeData>,
void_data: Option<types::PaymentsCancelData>,
payment_info: Option<PaymentInfo>,
) -> Result<types::PaymentsCancelRouterData, Report<ConnectorError>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/utils.rs | crate: router | connector: utils | op: void
use error_stack::Report;
use router::{
configs::settings::Settings,
core::{errors::ConnectorError, payments},
db::StorageImpl,
routes,
services::{
self,
connector_integration_interface::{BoxedConnectorIntegrationInterface, ConnectorEnum},
},
types::{self, storage::enums, AccessToken, MinorUnit, PaymentAddress, RouterData},
};
async fn void_payment(
&self,
transaction_id: String,
payment_data: Option<types::PaymentsCancelData>,
payment_info: Option<PaymentInfo>,
) -> Result<types::PaymentsCancelRouterData, Report<ConnectorError>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/utils.rs | crate: router | connector: utils | op: authorize
use error_stack::Report;
use router::{
configs::settings::Settings,
core::{errors::ConnectorError, payments},
db::StorageImpl,
routes,
services::{
self,
connector_integration_interface::{BoxedConnectorIntegrationInterface, ConnectorEnum},
},
types::{self, storage::enums, AccessToken, MinorUnit, PaymentAddress, RouterData},
};
async fn authorize_and_capture_payment(
&self,
authorize_data: Option<types::PaymentsAuthorizeData>,
capture_data: Option<types::PaymentsCaptureData>,
payment_info: Option<PaymentInfo>,
) -> Result<types::PaymentsCaptureRouterData, Report<ConnectorError>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/utils.rs | crate: router | connector: utils | op: capture
use error_stack::Report;
use router::{
configs::settings::Settings,
core::{errors::ConnectorError, payments},
db::StorageImpl,
routes,
services::{
self,
connector_integration_interface::{BoxedConnectorIntegrationInterface, ConnectorEnum},
},
types::{self, storage::enums, AccessToken, MinorUnit, PaymentAddress, RouterData},
};
async fn capture_payment(
&self,
transaction_id: String,
payment_data: Option<types::PaymentsCaptureData>,
payment_info: Option<PaymentInfo>,
) -> Result<types::PaymentsCaptureRouterData, Report<ConnectorError>> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/utils.rs | crate: router | connector: utils | op: sync
use std::{fmt::Debug, marker::PhantomData, str::FromStr, sync::Arc, time::Duration};
use error_stack::Report;
use router::{
configs::settings::Settings,
core::{errors::ConnectorError, payments},
db::StorageImpl,
routes,
services::{
self,
connector_integration_interface::{BoxedConnectorIntegrationInterface, ConnectorEnum},
},
types::{self, storage::enums, AccessToken, MinorUnit, PaymentAddress, RouterData},
};
/// will retry the psync till the given status matches or retry max 3 times
async fn psync_retry_till_status_matches(
&self,
status: enums::AttemptStatus,
payment_data: Option<types::PaymentsSyncData>,
payment_info: Option<PaymentInfo>,
) -> Result<types::PaymentsSyncRouterData, Report<ConnectorError>> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/utils.rs | crate: router | connector: utils | op: sync
use error_stack::Report;
use router::{
configs::settings::Settings,
core::{errors::ConnectorError, payments},
db::StorageImpl,
routes,
services::{
self,
connector_integration_interface::{BoxedConnectorIntegrationInterface, ConnectorEnum},
},
types::{self, storage::enums, AccessToken, MinorUnit, PaymentAddress, RouterData},
};
async fn sync_payment(
&self,
payment_data: Option<types::PaymentsSyncData>,
payment_info: Option<PaymentInfo>,
) -> Result<types::PaymentsSyncRouterData, Report<ConnectorError>> {
let integration = self.get_data().connector.get_connector_integration();
let request = self.generate_data(
payment_data.unwrap_or_else(|| PaymentSyncType::default().0),
payment_info,
);
Box::pin(call_connector(request, integration)).await
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/utils.rs | crate: router | connector: utils
use error_stack::Report;
use router::{
configs::settings::Settings,
core::{errors::ConnectorError, payments},
db::StorageImpl,
routes,
services::{
self,
connector_integration_interface::{BoxedConnectorIntegrationInterface, ConnectorEnum},
},
types::{self, storage::enums, AccessToken, MinorUnit, PaymentAddress, RouterData},
};
/// For initiating payments when `CaptureMethod` is set to `Automatic`
/// This does complete the transaction without user intervention to Capture the payment
async fn make_payment(
&self,
payment_data: Option<types::PaymentsAuthorizeData>,
payment_info: Option<PaymentInfo>,
) -> Result<types::PaymentsAuthorizeRouterData, Report<ConnectorError>> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/utils.rs | crate: router | connector: utils
use error_stack::Report;
use router::{
configs::settings::Settings,
core::{errors::ConnectorError, payments},
db::StorageImpl,
routes,
services::{
self,
connector_integration_interface::{BoxedConnectorIntegrationInterface, ConnectorEnum},
},
types::{self, storage::enums, AccessToken, MinorUnit, PaymentAddress, RouterData},
};
async fn create_connector_pm_token(
&self,
payment_data: Option<types::PaymentMethodTokenizationData>,
payment_info: Option<PaymentInfo>,
) -> Result<types::TokenizationRouterData, Report<ConnectorError>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/utils.rs | crate: router | connector: utils
use error_stack::Report;
use router::{
configs::settings::Settings,
core::{errors::ConnectorError, payments},
db::StorageImpl,
routes,
services::{
self,
connector_integration_interface::{BoxedConnectorIntegrationInterface, ConnectorEnum},
},
types::{self, storage::enums, AccessToken, MinorUnit, PaymentAddress, RouterData},
};
async fn create_connector_customer(
&self,
payment_data: Option<types::ConnectorCustomerData>,
payment_info: Option<PaymentInfo>,
) -> Result<types::ConnectorCustomerRouterData, Report<ConnectorError>> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/utils.rs | crate: router | connector: utils | op: authorize
use error_stack::Report;
use router::{
configs::settings::Settings,
core::{errors::ConnectorError, payments},
db::StorageImpl,
routes,
services::{
self,
connector_integration_interface::{BoxedConnectorIntegrationInterface, ConnectorEnum},
},
types::{self, storage::enums, AccessToken, MinorUnit, PaymentAddress, RouterData},
};
/// For initiating payments when `CaptureMethod` is set to `Manual`
/// This doesn't complete the transaction, `PaymentsCapture` needs to be done manually
async fn authorize_payment(
&self,
payment_data: Option<types::PaymentsAuthorizeData>,
payment_info: Option<PaymentInfo>,
) -> Result<types::PaymentsAuthorizeRouterData, Report<ConnectorError>> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/utils.rs | crate: router | connector: utils
use masking::Secret;
use router::{
configs::settings::Settings,
core::{errors::ConnectorError, payments},
db::StorageImpl,
routes,
services::{
self,
connector_integration_interface::{BoxedConnectorIntegrationInterface, ConnectorEnum},
},
types::{self, storage::enums, AccessToken, MinorUnit, PaymentAddress, RouterData},
};
pub fn with_default_billing_name() -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/tests/connectors/utils.rs | crate: router | connector: utils
use router::{
configs::settings::Settings,
core::{errors::ConnectorError, payments},
db::StorageImpl,
routes,
services::{
self,
connector_integration_interface::{BoxedConnectorIntegrationInterface, ConnectorEnum},
},
types::{self, storage::enums, AccessToken, MinorUnit, PaymentAddress, RouterData},
};
pub fn construct_connector_data_old(
connector: types::api::BoxedConnector,
connector_name: types::Connector,
get_token: types::api::GetToken,
merchant_connector_id: Option<common_utils::id_type::MerchantConnectorAccountId>,
) -> types::api::ConnectorData {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/router/tests/connectors/utils.rs | crate: router | connector: utils
use router::{
configs::settings::Settings,
core::{errors::ConnectorError, payments},
db::StorageImpl,
routes,
services::{
self,
connector_integration_interface::{BoxedConnectorIntegrationInterface, ConnectorEnum},
},
types::{self, storage::enums, AccessToken, MinorUnit, PaymentAddress, RouterData},
};
/// interval in seconds to be followed when making the subsequent request whenever needed
fn get_request_interval(&self) -> u64 {
5
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/types.rs | crate: router
psd2_sca_exemption_type: data.psd2_sca_exemption_type,
}
}
}
#[cfg(feature = "payouts")]
impl<F1, F2>
ForeignFrom<(
&RouterData<F1, PayoutsData, PayoutsResponseData>,
PayoutsData,
)> for RouterData<F2, PayoutsData, PayoutsResponseData>
{
fn foreign_from(
item: (
&RouterData<F1, PayoutsData, PayoutsResponseData>,
PayoutsData,
),
) -> Self {
let data = item.0;
let request = item.1;
Self {
flow: PhantomData,
request,
merchant_id: data.merchant_id.clone(),
connector: data.connector.clone(),
fn foreign_from(
item: (
&RouterData<F1, PayoutsData, PayoutsResponseData>,
PayoutsData,
),
) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/types.rs | crate: router
integrity_object: None,
additional_payment_method_data: None,
shipping_cost: data.request.shipping_cost,
merchant_account_id: None,
merchant_config_currency: None,
}
}
}
impl<F1, F2, T1, T2> ForeignFrom<(&RouterData<F1, T1, PaymentsResponseData>, T2)>
for RouterData<F2, T2, PaymentsResponseData>
{
fn foreign_from(item: (&RouterData<F1, T1, PaymentsResponseData>, T2)) -> Self {
let data = item.0;
let request = item.1;
Self {
flow: PhantomData,
request,
merchant_id: data.merchant_id.clone(),
connector: data.connector.clone(),
attempt_id: data.attempt_id.clone(),
tenant_id: data.tenant_id.clone(),
status: data.status,
payment_method: data.payment_method,
connector_auth_type: data.connector_auth_type.clone(),
fn foreign_from(item: (&RouterData<F1, T1, PaymentsResponseData>, T2)) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/types.rs | crate: router
pub use api_models::{enums::Connector, mandates};
pub use common_utils::{pii, pii::Email, request::RequestContent, types::MinorUnit};
pub type SetupMandateRouterData =
RouterData<SetupMandate, SetupMandateRequestData, PaymentsResponseData>;
fn foreign_from(data: &SetupMandateRouterData) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/types.rs | crate: router
api_models::admin::ConnectorAuthType::CertificateAuth {
certificate,
private_key,
} => Self::CertificateAuth {
certificate,
private_key,
},
}
}
}
impl ForeignFrom<ConnectorAuthType> for api_models::admin::ConnectorAuthType {
fn foreign_from(from: ConnectorAuthType) -> Self {
match from {
ConnectorAuthType::TemporaryAuth => Self::TemporaryAuth,
ConnectorAuthType::HeaderKey { api_key } => Self::HeaderKey { api_key },
ConnectorAuthType::BodyKey { api_key, key1 } => Self::BodyKey { api_key, key1 },
ConnectorAuthType::SignatureKey {
api_key,
key1,
api_secret,
} => Self::SignatureKey {
api_key,
key1,
api_secret,
fn foreign_from(from: ConnectorAuthType) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/types.rs | crate: router
fn foreign_from(value: AdditionalMerchantData) -> Self {
match value {
AdditionalMerchantData::OpenBankingRecipientData(data) => {
Self::OpenBankingRecipientData(
api_models::admin::MerchantRecipientData::foreign_from(data),
)
}
}
}
}
impl ForeignFrom<api_models::admin::ConnectorAuthType> for ConnectorAuthType {
fn foreign_from(value: api_models::admin::ConnectorAuthType) -> Self {
match value {
api_models::admin::ConnectorAuthType::TemporaryAuth => Self::TemporaryAuth,
api_models::admin::ConnectorAuthType::HeaderKey { api_key } => {
Self::HeaderKey { api_key }
}
api_models::admin::ConnectorAuthType::BodyKey { api_key, key1 } => {
Self::BodyKey { api_key, key1 }
}
api_models::admin::ConnectorAuthType::SignatureKey {
api_key,
key1,
api_secret,
fn foreign_from(value: api_models::admin::ConnectorAuthType) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/types.rs | crate: router
fn foreign_from(from: MerchantAccountData) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/types.rs | crate: router
pub use api_models::{enums::PayoutConnectors, payouts as payout_types};
use hyperswitch_domain_models::router_flow_types::{
self,
access_token_auth::AccessTokenAuth,
dispute::{Accept, Defend, Evidence},
files::{Retrieve, Upload},
mandate_revoke::MandateRevoke,
payments::{
Approve, Authorize, AuthorizeSessionToken, Balance, CalculateTax, Capture,
CompleteAuthorize, CreateConnectorCustomer, IncrementalAuthorization, InitPayment, PSync,
PostProcessing, PostSessionTokens, PreProcessing, Reject, SdkSessionUpdate, Session,
SetupMandate, Void,
},
refunds::{Execute, RSync},
webhooks::VerifyWebhookSource,
};
use crate::{
consts,
core::{
errors::{self},
payments::{OperationSessionGetters, PaymentData},
},
services,
types::transformers::{ForeignFrom, ForeignTryFrom},
};
pub type RefundsRouterData<F> = RouterData<F, RefundsData, RefundsResponseData>;
pub type RefundsResponseRouterData<F, R> =
ResponseRouterData<F, R, RefundsData, RefundsResponseData>;
pub type PayoutsRouterData<F> = RouterData<F, PayoutsData, PayoutsResponseData>;
pub type PayoutsResponseRouterData<F, R> =
ResponseRouterData<F, R, PayoutsData, PayoutsResponseData>;
pub type PayoutActionData = Vec<(
storage::Payouts,
storage::PayoutAttempt,
Option<domain::Customer>,
Option<api_models::payments::Address>,
)>;
fn get_amount_capturable<F>(
&self,
payment_data: &PaymentData<F>,
attempt_status: common_enums::AttemptStatus,
) -> Option<i64>
where
F: Clone,
{
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/types.rs | crate: router
fn foreign_from(value: AdditionalMerchantData) -> Self {
match value {
AdditionalMerchantData::OpenBankingRecipientData(data) => {
Self::OpenBankingRecipientData(
api_models::admin::MerchantRecipientData::foreign_from(data),
)
}
}
}
}
impl ForeignFrom<api_models::admin::ConnectorAuthType> for ConnectorAuthType {
fn foreign_from(value: api_models::admin::ConnectorAuthType) -> Self {
match value {
api_models::admin::ConnectorAuthType::TemporaryAuth => Self::TemporaryAuth,
api_models::admin::ConnectorAuthType::HeaderKey { api_key } => {
Self::HeaderKey { api_key }
}
api_models::admin::ConnectorAuthType::BodyKey { api_key, key1 } => {
Self::BodyKey { api_key, key1 }
}
api_models::admin::ConnectorAuthType::SignatureKey {
api_key,
key1,
api_secret,
fn foreign_from(value: api_models::admin::ConnectorAuthType) -> Self {
{
api_models::admin::ConnectorAuthType::TemporaryAuth => Self::TemporaryAuth,<|fim_suffix|>
<|fim_middle|>
api_models::admin::ConnectorAuthType::CertificateAuth {
certificate,
private_key,
} => Self::CertificateAuth {
certificate,
private_key,
},
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/types.rs | crate: router
pub use api_models::{enums::Connector, mandates};
pub use api_models::{enums::PayoutConnectors, payouts as payout_types};
pub type PayoutActionData = Vec<(
storage::Payouts,
storage::PayoutAttempt,
Option<domain::Customer>,
Option<api_models::payments::Address>,
)>;
fn from(value: api_models::admin::MerchantRecipientData) -> Self {
{
api_models::admin::MerchantRecipientData::ConnectorRecipientId(id) => {
Self::ConnectorRecipientId(id)
}<|fim_suffix|>
<|fim_middle|>
api_models::admin::MerchantRecipientData::AccountData(data) => {
Self::AccountData(data.into())
}
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/types.rs | crate: router
.clone(),
},
);
Self { revenue_recovery }
}
}
#[cfg(feature = "v2")]
impl ForeignTryFrom<&api_models::admin::MerchantConnectorAccountFeatureMetadata>
for domain::MerchantConnectorAccountFeatureMetadata
{
type Error = errors::ApiErrorResponse;
fn foreign_try_from(
feature_metadata: &api_models::admin::MerchantConnectorAccountFeatureMetadata,
) -> Result<Self, Self::Error> {
let revenue_recovery = feature_metadata
.revenue_recovery
.as_ref()
.map(|revenue_recovery_metadata| {
domain::AccountReferenceMap::new(
revenue_recovery_metadata.billing_account_reference.clone(),
)
.map(|mca_reference| domain::RevenueRecoveryMetadata {
max_retry_count: revenue_recovery_metadata.max_retry_count,
billing_connector_retry_threshold: revenue_recovery_metadata
fn foreign_try_from(
feature_metadata: &api_models::admin::MerchantConnectorAccountFeatureMetadata,
) -> Result<Self, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/types.rs | crate: router
authentication_id: None,
psd2_sca_exemption_type: None,
additional_merchant_data: data.additional_merchant_data.clone(),
connector_mandate_request_reference_id: None,
}
}
}
#[cfg(feature = "v2")]
impl ForeignFrom<&domain::MerchantConnectorAccountFeatureMetadata>
for api_models::admin::MerchantConnectorAccountFeatureMetadata
{
fn foreign_from(item: &domain::MerchantConnectorAccountFeatureMetadata) -> Self {
let revenue_recovery = item
.revenue_recovery
.as_ref()
.map(
|revenue_recovery_metadata| api_models::admin::RevenueRecoveryMetadata {
max_retry_count: revenue_recovery_metadata.max_retry_count,
billing_connector_retry_threshold: revenue_recovery_metadata
.billing_connector_retry_threshold,
billing_account_reference: revenue_recovery_metadata
.mca_reference
.recovery_to_billing
.clone(),
fn foreign_from(item: &domain::MerchantConnectorAccountFeatureMetadata) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/types.rs | crate: router
use hyperswitch_domain_models::router_flow_types::{
self,
access_token_auth::AccessTokenAuth,
dispute::{Accept, Defend, Evidence},
files::{Retrieve, Upload},
mandate_revoke::MandateRevoke,
payments::{
Approve, Authorize, AuthorizeSessionToken, Balance, CalculateTax, Capture,
CompleteAuthorize, CreateConnectorCustomer, IncrementalAuthorization, InitPayment, PSync,
PostProcessing, PostSessionTokens, PreProcessing, Reject, SdkSessionUpdate, Session,
SetupMandate, Void,
},
refunds::{Execute, RSync},
webhooks::VerifyWebhookSource,
};
use crate::{
consts,
core::{
errors::{self},
payments::{OperationSessionGetters, PaymentData},
},
services,
types::transformers::{ForeignFrom, ForeignTryFrom},
};
pub type PayoutActionData = Vec<(
storage::Payouts,
storage::PayoutAttempt,
Option<domain::Customer>,
Option<api_models::payments::Address>,
)>;
fn set_session_token(&mut self, _token: Option<String>) {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/types.rs | crate: router
use hyperswitch_domain_models::router_flow_types::{
self,
access_token_auth::AccessTokenAuth,
dispute::{Accept, Defend, Evidence},
files::{Retrieve, Upload},
mandate_revoke::MandateRevoke,
payments::{
Approve, Authorize, AuthorizeSessionToken, Balance, CalculateTax, Capture,
CompleteAuthorize, CreateConnectorCustomer, IncrementalAuthorization, InitPayment, PSync,
PostProcessing, PostSessionTokens, PreProcessing, Reject, SdkSessionUpdate, Session,
SetupMandate, Void,
},
refunds::{Execute, RSync},
webhooks::VerifyWebhookSource,
};
use crate::{
consts,
core::{
errors::{self},
payments::{OperationSessionGetters, PaymentData},
},
services,
types::transformers::{ForeignFrom, ForeignTryFrom},
};
pub type PayoutActionData = Vec<(
storage::Payouts,
storage::PayoutAttempt,
Option<domain::Customer>,
Option<api_models::payments::Address>,
)>;
fn set_session_token(&mut self, token: Option<String>) {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/types.rs | crate: router
pub use common_utils::{pii, pii::Email, request::RequestContent, types::MinorUnit};
pub type PaymentsAuthorizeRouterData =
RouterData<Authorize, PaymentsAuthorizeData, PaymentsResponseData>;
fn foreign_from(data: &PaymentsAuthorizeRouterData) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/types.rs | crate: router
},
}
}
}
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct ConnectorsList {
pub connectors: Vec<String>,
}
impl ForeignTryFrom<ConnectorAuthType> for AccessTokenRequestData {
type Error = errors::ApiErrorResponse;
fn foreign_try_from(connector_auth: ConnectorAuthType) -> Result<Self, Self::Error> {
match connector_auth {
ConnectorAuthType::HeaderKey { api_key } => Ok(Self {
app_id: api_key,
id: None,
}),
ConnectorAuthType::BodyKey { api_key, key1 } => Ok(Self {
app_id: api_key,
id: Some(key1),
}),
ConnectorAuthType::SignatureKey { api_key, key1, .. } => Ok(Self {
app_id: api_key,
id: Some(key1),
fn foreign_try_from(connector_auth: ConnectorAuthType) -> Result<Self, Self::Error> {
{
ConnectorAuthType::HeaderKey { api_key } => Ok(Self {
app_id: api_key,
id: None,
}),<|fim_suffix|>
<|fim_middle|>
_ => Err(errors::ApiErrorResponse::InvalidDataValue {
field_name: "connector_account_details",
}),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/types.rs | crate: router
pub use api_models::{enums::Connector, mandates};
pub use api_models::{enums::PayoutConnectors, payouts as payout_types};
pub type PayoutActionData = Vec<(
storage::Payouts,
storage::PayoutAttempt,
Option<domain::Customer>,
Option<api_models::payments::Address>,
)>;
fn foreign_from(value: AdditionalMerchantData) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/types.rs | crate: router
pub use api_models::{enums::Connector, mandates};
pub use api_models::{enums::PayoutConnectors, payouts as payout_types};
pub type PayoutActionData = Vec<(
storage::Payouts,
storage::PayoutAttempt,
Option<domain::Customer>,
Option<api_models::payments::Address>,
)>;
fn foreign_from(value: api_models::admin::AdditionalMerchantData) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/types.rs | crate: router
pub use api_models::{enums::Connector, mandates};
pub use api_models::{enums::PayoutConnectors, payouts as payout_types};
pub type PayoutActionData = Vec<(
storage::Payouts,
storage::PayoutAttempt,
Option<domain::Customer>,
Option<api_models::payments::Address>,
)>;
fn from(value: api_models::admin::MerchantRecipientData) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/types.rs | crate: router
pub use api_models::{enums::Connector, mandates};
pub use api_models::{enums::PayoutConnectors, payouts as payout_types};
pub type PayoutActionData = Vec<(
storage::Payouts,
storage::PayoutAttempt,
Option<domain::Customer>,
Option<api_models::payments::Address>,
)>;
fn foreign_from(value: MerchantRecipientData) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/types.rs | crate: router
pub use api_models::{enums::Connector, mandates};
pub use api_models::{enums::PayoutConnectors, payouts as payout_types};
pub type PayoutActionData = Vec<(
storage::Payouts,
storage::PayoutAttempt,
Option<domain::Customer>,
Option<api_models::payments::Address>,
)>;
fn from(from: api_models::admin::MerchantAccountData) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/router/src/types.rs | crate: router
use crate::{
consts,
core::{
errors::{self},
payments::{OperationSessionGetters, PaymentData},
},
services,
types::transformers::{ForeignFrom, ForeignTryFrom},
};
fn default() -> Self {
Self {
delay_in_secs: consts::DEFAULT_POLL_DELAY_IN_SECS,
frequency: consts::DEFAULT_POLL_FREQUENCY,
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/types.rs | crate: router
pub enum Redirection {
Redirect,
NoRedirect,
}
#[derive(Debug, Clone, serde::Deserialize, serde::Serialize)]
pub struct PollConfig {
pub delay_in_secs: i8,
pub frequency: i8,
}
impl PollConfig {
pub fn get_poll_config_key(connector: String) -> String {
format!("poll_config_external_three_ds_{connector}")
}
}
impl Default for PollConfig {
fn default() -> Self {
Self {
delay_in_secs: consts::DEFAULT_POLL_DELAY_IN_SECS,
frequency: consts::DEFAULT_POLL_FREQUENCY,
}
}
}
pub fn get_poll_config_key(connector: String) -> String {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/types.rs | crate: router
use hyperswitch_domain_models::router_flow_types::{
self,
access_token_auth::AccessTokenAuth,
dispute::{Accept, Defend, Evidence},
files::{Retrieve, Upload},
mandate_revoke::MandateRevoke,
payments::{
Approve, Authorize, AuthorizeSessionToken, Balance, CalculateTax, Capture,
CompleteAuthorize, CreateConnectorCustomer, IncrementalAuthorization, InitPayment, PSync,
PostProcessing, PostSessionTokens, PreProcessing, Reject, SdkSessionUpdate, Session,
SetupMandate, Void,
},
refunds::{Execute, RSync},
webhooks::VerifyWebhookSource,
};
use crate::{
consts,
core::{
errors::{self},
payments::{OperationSessionGetters, PaymentData},
},
services,
types::transformers::{ForeignFrom, ForeignTryFrom},
};
pub type RefundsRouterData<F> = RouterData<F, RefundsData, RefundsResponseData>;
pub type RefundsResponseRouterData<F, R> =
ResponseRouterData<F, R, RefundsData, RefundsResponseData>;
pub type PayoutsRouterData<F> = RouterData<F, PayoutsData, PayoutsResponseData>;
pub type PayoutsResponseRouterData<F, R> =
ResponseRouterData<F, R, PayoutsData, PayoutsResponseData>;
pub type PayoutActionData = Vec<(
storage::Payouts,
storage::PayoutAttempt,
Option<domain::Customer>,
Option<api_models::payments::Address>,
)>;
fn get_amount_capturable<F>(
&self,
_payment_data: &PaymentData<F>,
attempt_status: common_enums::AttemptStatus,
) -> Option<i64>
where
F: Clone,
{
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/router/src/types.rs | crate: router
use hyperswitch_domain_models::router_flow_types::{
self,
access_token_auth::AccessTokenAuth,
dispute::{Accept, Defend, Evidence},
files::{Retrieve, Upload},
mandate_revoke::MandateRevoke,
payments::{
Approve, Authorize, AuthorizeSessionToken, Balance, CalculateTax, Capture,
CompleteAuthorize, CreateConnectorCustomer, IncrementalAuthorization, InitPayment, PSync,
PostProcessing, PostSessionTokens, PreProcessing, Reject, SdkSessionUpdate, Session,
SetupMandate, Void,
},
refunds::{Execute, RSync},
webhooks::VerifyWebhookSource,
};
use crate::{
consts,
core::{
errors::{self},
payments::{OperationSessionGetters, PaymentData},
},
services,
types::transformers::{ForeignFrom, ForeignTryFrom},
};
pub type RefundsRouterData<F> = RouterData<F, RefundsData, RefundsResponseData>;
pub type RefundsResponseRouterData<F, R> =
ResponseRouterData<F, R, RefundsData, RefundsResponseData>;
pub type PayoutsRouterData<F> = RouterData<F, PayoutsData, PayoutsResponseData>;
pub type PayoutsResponseRouterData<F, R> =
ResponseRouterData<F, R, PayoutsData, PayoutsResponseData>;
pub type PayoutActionData = Vec<(
storage::Payouts,
storage::PayoutAttempt,
Option<domain::Customer>,
Option<api_models::payments::Address>,
)>;
fn get_captured_amount<F>(&self, payment_data: &PaymentData<F>) -> Option<i64>
where
F: Clone,
{
<|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.