text
stringlengths 70
351k
| source
stringclasses 4
values |
|---|---|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree/transformers.rs<|crate|> hyperswitch_connectors<|connector|> braintree anchor=from kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree/transformers.rs" role="context" start="960" end="968">
fn from(item: BraintreeRefundStatus) -> Self {
match item {
BraintreeRefundStatus::Settled
| BraintreeRefundStatus::Settling
| BraintreeRefundStatus::SubmittedForSettlement
| BraintreeRefundStatus::SettlementPending => Self::Success,
BraintreeRefundStatus::Failed => Self::Failure,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree/transformers.rs" role="context" start="1039" end="1073">
fn try_from(item: &types::RefundSyncRouterData) -> Result<Self, Self::Error> {
let metadata: BraintreeMeta = if let (
Some(merchant_account_id),
Some(merchant_config_currency),
) = (
item.request.merchant_account_id.clone(),
item.request.merchant_config_currency,
) {
router_env::logger::info!(
"BRAINTREE: Picking merchant_account_id and merchant_config_currency from payments request"
);
BraintreeMeta {
merchant_account_id,
merchant_config_currency,
}
} else {
utils::to_connector_meta_from_secret(item.connector_meta_data.clone()).change_context(
errors::ConnectorError::InvalidConnectorConfig { config: "metadata" },
)?
};
utils::validate_currency(
item.request.currency,
Some(metadata.merchant_config_currency),
)?;
let refund_id = item.request.get_connector_refund_id()?;
Ok(Self {
query: REFUND_QUERY.to_string(),
variables: RSyncInput {
input: RefundSearchInput {
id: IdFilter { is: refund_id },
},
},
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree/transformers.rs" role="context" start="997" end="1030">
fn try_from(
item: RefundsResponseRouterData<Execute, BraintreeRefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: match item.response {
BraintreeRefundResponse::ErrorResponse(error_response) => {
build_error_response(&error_response.errors, item.http_code).map_err(|err| *err)
}
BraintreeRefundResponse::SuccessResponse(refund_data) => {
let refund_data = refund_data.data.refund_transaction.refund;
let refund_status = enums::RefundStatus::from(refund_data.status.clone());
if utils::is_refund_failure(refund_status) {
Err(hyperswitch_domain_models::router_data::ErrorResponse {
code: refund_data.status.to_string().clone(),
message: refund_data.status.to_string().clone(),
reason: Some(refund_data.status.to_string().clone()),
attempt_status: None,
connector_transaction_id: Some(refund_data.id),
status_code: item.http_code,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
} else {
Ok(RefundsResponseData {
connector_refund_id: refund_data.id.clone(),
refund_status,
})
}
}
},
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree/transformers.rs" role="context" start="907" end="946">
fn try_from(item: BraintreeRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
let metadata: BraintreeMeta = if let (
Some(merchant_account_id),
Some(merchant_config_currency),
) = (
item.router_data.request.merchant_account_id.clone(),
item.router_data.request.merchant_config_currency,
) {
router_env::logger::info!(
"BRAINTREE: Picking merchant_account_id and merchant_config_currency from payments request"
);
BraintreeMeta {
merchant_account_id,
merchant_config_currency,
}
} else {
utils::to_connector_meta_from_secret(item.router_data.connector_meta_data.clone())
.change_context(errors::ConnectorError::InvalidConnectorConfig {
config: "metadata",
})?
};
utils::validate_currency(
item.router_data.request.currency,
Some(metadata.merchant_config_currency),
)?;
let query = REFUND_TRANSACTION_MUTATION.to_string();
let variables = BraintreeRefundVariables {
input: BraintreeRefundInput {
transaction_id: item.router_data.request.connector_transaction_id.clone(),
refund: RefundInputData {
amount: item.amount,
merchant_account_id: metadata.merchant_account_id,
order_id: item.router_data.refund_id.clone(),
},
},
};
Ok(Self { query, variables })
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree/transformers.rs" role="context" start="797" end="852">
fn try_from(
item: ResponseRouterData<
F,
BraintreeCompleteAuthResponse,
CompleteAuthorizeData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
match item.response {
BraintreeCompleteAuthResponse::ErrorResponse(error_response) => Ok(Self {
response: build_error_response(&error_response.errors, item.http_code)
.map_err(|err| *err),
..item.data
}),
BraintreeCompleteAuthResponse::AuthResponse(auth_response) => {
let transaction_data = auth_response.data.authorize_credit_card.transaction;
let status = enums::AttemptStatus::from(transaction_data.status.clone());
let response = if utils::is_payment_failure(status) {
Err(hyperswitch_domain_models::router_data::ErrorResponse {
code: transaction_data.status.to_string().clone(),
message: transaction_data.status.to_string().clone(),
reason: Some(transaction_data.status.to_string().clone()),
attempt_status: None,
connector_transaction_id: Some(transaction_data.id),
status_code: item.http_code,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
} else {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(transaction_data.id),
redirection_data: Box::new(None),
mandate_reference: Box::new(transaction_data.payment_method.as_ref().map(
|pm| MandateReference {
connector_mandate_id: Some(pm.id.clone().expose()),
payment_method_id: None,
mandate_metadata: None,
connector_mandate_request_reference_id: None,
},
)),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
})
};
Ok(Self {
status,
response,
..item.data
})
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree/transformers.rs" role="context" start="1118" end="1146">
fn try_from(
item: RefundsResponseRouterData<RSync, BraintreeRSyncResponse>,
) -> Result<Self, Self::Error> {
match item.response {
BraintreeRSyncResponse::ErrorResponse(error_response) => Ok(Self {
response: build_error_response(&error_response.errors, item.http_code)
.map_err(|err| *err),
..item.data
}),
BraintreeRSyncResponse::RSyncResponse(rsync_response) => {
let edge_data = rsync_response
.data
.search
.refunds
.edges
.first()
.ok_or(errors::ConnectorError::MissingConnectorRefundID)?;
let connector_refund_id = &edge_data.node.id;
let response = Ok(RefundsResponseData {
connector_refund_id: connector_refund_id.to_string(),
refund_status: enums::RefundStatus::from(edge_data.node.status.clone()),
});
Ok(Self {
response,
..item.data
})
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree/transformers.rs" role="context" start="1561" end="1604">
fn try_from(
item: ResponseRouterData<F, BraintreeCancelResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
match item.response {
BraintreeCancelResponse::ErrorResponse(error_response) => Ok(Self {
response: build_error_response(&error_response.errors, item.http_code)
.map_err(|err| *err),
..item.data
}),
BraintreeCancelResponse::CancelResponse(void_response) => {
let void_data = void_response.data.reverse_transaction.reversal;
let status = enums::AttemptStatus::from(void_data.status.clone());
let response = if utils::is_payment_failure(status) {
Err(hyperswitch_domain_models::router_data::ErrorResponse {
code: void_data.status.to_string().clone(),
message: void_data.status.to_string().clone(),
reason: Some(void_data.status.to_string().clone()),
attempt_status: None,
connector_transaction_id: None,
status_code: item.http_code,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
} else {
Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::NoResponseId,
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
})
};
Ok(Self {
status,
response,
..item.data
})
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree/transformers.rs" role="context" start="951" end="957">
pub enum BraintreeRefundStatus {
SettlementPending,
Settling,
Settled,
SubmittedForSettlement,
Failed,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/aci/transformers.rs<|crate|> hyperswitch_connectors<|connector|> aci anchor=try_from kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/aci/transformers.rs" role="context" start="842" end="854">
fn try_from(
item: RefundsResponseRouterData<F, AciRefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.id,
refund_status: enums::RefundStatus::from(AciRefundStatus::from_str(
&item.response.result.code,
)?),
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/aci/transformers.rs" role="context" start="841" end="841">
use common_enums::enums;
use hyperswitch_domain_models::{
payment_method_data::{BankRedirectData, Card, PayLaterData, PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, RouterData},
router_request_types::ResponseId,
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{PaymentsAuthorizeRouterData, PaymentsCancelRouterData, RefundsRouterData},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{self, PhoneDetailsData, RouterData as _},
};
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/aci/transformers.rs" role="context" start="819" end="825">
fn from(item: AciRefundStatus) -> Self {
match item {
AciRefundStatus::Succeeded => Self::Success,
AciRefundStatus::Failed => Self::Failure,
AciRefundStatus::Pending => Self::Pending,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/aci/transformers.rs" role="context" start="803" end="815">
fn from_str(s: &str) -> Result<Self, Self::Err> {
if FAILURE_CODES.contains(&s) {
Ok(Self::Failed)
} else if PENDING_CODES.contains(&s) {
Ok(Self::Pending)
} else if SUCCESSFUL_CODES.contains(&s) {
Ok(Self::Succeeded)
} else {
Err(report!(errors::ConnectorError::UnexpectedResponseError(
bytes::Bytes::from(s.to_owned())
)))
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/aci/transformers.rs" role="context" start="493" end="509">
fn try_from(
value: (
&AciRouterData<&PaymentsAuthorizeRouterData>,
&BankRedirectData,
),
) -> Result<Self, Self::Error> {
let (item, bank_redirect_data) = value;
let txn_details = get_transaction_details(item)?;
let payment_method = PaymentDetails::try_from((item, bank_redirect_data))?;
Ok(Self {
txn_details,
payment_method,
instruction: None,
shopper_result_url: item.router_data.request.router_return_url.clone(),
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/aci/transformers.rs" role="context" start="611" end="618">
fn try_from(item: &PaymentsCancelRouterData) -> Result<Self, Self::Error> {
let auth = AciAuthType::try_from(&item.connector_auth_type)?;
let aci_payment_request = Self {
entity_id: auth.entity_id,
payment_type: AciPaymentType::Reversal,
};
Ok(aci_payment_request)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/aci/transformers.rs" role="context" start="26" end="26">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/aci/transformers.rs" role="context" start="831" end="838">
pub struct AciRefundResponse {
id: String,
//ndc is an internal unique identifier for the request.
ndc: String,
timestamp: String,
build_number: String,
pub(super) result: ResultCode,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/chargebee/transformers.rs" role="context" start="193" end="198">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/payment_methods.rs" role="context" start="2478" end="2478">
type Error = error_stack::Report<errors::ValidationError>;
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei/transformers.rs<|crate|> hyperswitch_connectors<|connector|> nuvei anchor=try_from kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei/transformers.rs" role="context" start="1742" end="1765">
fn try_from(data: &RouterData<F, Req, PaymentsResponseData>) -> Result<Self, Self::Error> {
{
let item = data;
let connector_mandate_id = &item.request.get_connector_mandate_id();
let related_transaction_id = if item.is_three_ds() {
item.request.get_related_transaction_id().clone()
} else {
None
};
Ok(Self {
related_transaction_id,
device_details: Option::<DeviceDetails>::foreign_try_from(
&item.request.get_browser_info().clone(),
)?,
is_rebilling: Some("1".to_string()), // In case of second installment, rebilling should be 1
user_token_id: Some(item.request.get_email_required()?),
payment_option: PaymentOption {
user_payment_option_id: connector_mandate_id.clone(),
..Default::default()
},
..Default::default()
})
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei/transformers.rs" role="context" start="1741" end="1741">
use hyperswitch_domain_models::{
mandates::{MandateData, MandateDataType},
payment_method_data::{
self, ApplePayWalletData, BankRedirectData, GooglePayWalletData, PayLaterData,
PaymentMethodData, WalletData,
},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::{
refunds::{Execute, RSync},
Authorize, Capture, CompleteAuthorize, PSync, Void,
},
router_request_types::{
BrowserInformation, PaymentsAuthorizeData, PaymentsPreProcessingData, ResponseId,
},
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types,
};
use crate::{
types::{
PaymentsPreprocessingResponseRouterData, RefundsResponseRouterData, ResponseRouterData,
},
utils::{
self, AddressDetailsData, BrowserInformationData, ForeignTryFrom,
PaymentsAuthorizeRequestData, PaymentsCancelRequestData, PaymentsPreProcessingRequestData,
RouterData as _,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei/transformers.rs" role="context" start="1781" end="1805">
fn get_refund_response(
response: NuveiPaymentsResponse,
http_code: u16,
txn_id: String,
) -> Result<RefundsResponseData, Box<ErrorResponse>> {
let refund_status = response
.transaction_status
.clone()
.map(enums::RefundStatus::from)
.unwrap_or(enums::RefundStatus::Failure);
match response.status {
NuveiPaymentStatus::Error => {
get_error_response(response.err_code, &response.reason, http_code)
}
_ => match response.transaction_status {
Some(NuveiTransactionStatus::Error) => {
get_error_response(response.gw_error_code, &response.gw_error_reason, http_code)
}
_ => Ok(RefundsResponseData {
connector_refund_id: txn_id,
refund_status,
}),
},
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei/transformers.rs" role="context" start="1770" end="1778">
fn foreign_try_from(browser_info: &Option<BrowserInformation>) -> Result<Self, Self::Error> {
let device_details = match browser_info {
Some(browser_info) => Some(DeviceDetails {
ip_address: browser_info.get_ip_address()?,
}),
None => None,
};
Ok(device_details)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei/transformers.rs" role="context" start="1720" end="1734">
fn try_from(
item: RefundsResponseRouterData<RSync, NuveiPaymentsResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: get_refund_response(
item.response.clone(),
item.http_code,
item.response
.transaction_id
.ok_or(errors::ConnectorError::MissingConnectorTransactionID)?,
)
.map_err(|err| *err),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei/transformers.rs" role="context" start="1699" end="1713">
fn try_from(
item: RefundsResponseRouterData<Execute, NuveiPaymentsResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: get_refund_response(
item.response.clone(),
item.http_code,
item.response
.transaction_id
.ok_or(errors::ConnectorError::MissingConnectorTransactionID)?,
)
.map_err(|err| *err),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei/transformers.rs" role="context" start="1385" end="1397">
fn try_from(item: &types::PaymentsCancelRouterData) -> Result<Self, Self::Error> {
Self::try_from(NuveiPaymentRequestData {
client_request_id: item.connector_request_reference_id.clone(),
connector_auth_type: item.connector_auth_type.clone(),
amount: utils::to_currency_base_unit(
item.request.get_amount()?,
item.request.get_currency()?,
)?,
currency: item.request.get_currency()?,
related_transaction_id: Some(item.request.connector_transaction_id.clone()),
..Default::default()
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei/transformers.rs" role="context" start="543" end="565">
fn try_from(
item: &types::PaymentsAuthorizeSessionTokenRouterData,
) -> Result<Self, Self::Error> {
let connector_meta: NuveiAuthType = NuveiAuthType::try_from(&item.connector_auth_type)?;
let merchant_id = connector_meta.merchant_id;
let merchant_site_id = connector_meta.merchant_site_id;
let client_request_id = item.connector_request_reference_id.clone();
let time_stamp = date_time::DateTime::<date_time::YYYYMMDDHHmmss>::from(date_time::now());
let merchant_secret = connector_meta.merchant_secret;
Ok(Self {
merchant_id: merchant_id.clone(),
merchant_site_id: merchant_site_id.clone(),
client_request_id: client_request_id.clone(),
time_stamp: time_stamp.clone(),
checksum: Secret::new(encode_payload(&[
merchant_id.peek(),
merchant_site_id.peek(),
&client_request_id,
&time_stamp.to_string(),
merchant_secret.peek(),
])?),
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei/transformers.rs" role="context" start="542" end="542">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei/transformers.rs" role="context" start="477" end="479">
pub struct DeviceDetails {
pub ip_address: Secret<String, IpAddress>,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/utils.rs" role="context" start="455" end="516">
pub trait RouterData {
fn get_billing(&self) -> Result<&Address, Error>;
fn get_billing_country(&self) -> Result<api_models::enums::CountryAlpha2, Error>;
fn get_billing_phone(&self) -> Result<&PhoneDetails, Error>;
fn get_description(&self) -> Result<String, Error>;
fn get_billing_address(&self) -> Result<&AddressDetails, Error>;
fn get_shipping_address(&self) -> Result<&AddressDetails, Error>;
fn get_shipping_address_with_phone_number(&self) -> Result<&Address, Error>;
fn get_connector_meta(&self) -> Result<pii::SecretSerdeValue, Error>;
fn get_session_token(&self) -> Result<String, Error>;
fn get_billing_first_name(&self) -> Result<Secret<String>, Error>;
fn get_billing_full_name(&self) -> Result<Secret<String>, Error>;
fn get_billing_last_name(&self) -> Result<Secret<String>, Error>;
fn get_billing_line1(&self) -> Result<Secret<String>, Error>;
fn get_billing_line2(&self) -> Result<Secret<String>, Error>;
fn get_billing_zip(&self) -> Result<Secret<String>, Error>;
fn get_billing_state(&self) -> Result<Secret<String>, Error>;
fn get_billing_state_code(&self) -> Result<Secret<String>, Error>;
fn get_billing_city(&self) -> Result<String, Error>;
fn get_billing_email(&self) -> Result<Email, Error>;
fn get_billing_phone_number(&self) -> Result<Secret<String>, Error>;
fn to_connector_meta<T>(&self) -> Result<T, Error>
where
T: serde::de::DeserializeOwned;
fn is_three_ds(&self) -> bool;
fn get_payment_method_token(&self) -> Result<PaymentMethodToken, Error>;
fn get_customer_id(&self) -> Result<id_type::CustomerId, Error>;
fn get_connector_customer_id(&self) -> Result<String, Error>;
fn get_preprocessing_id(&self) -> Result<String, Error>;
fn get_recurring_mandate_payment_data(&self) -> Result<RecurringMandatePaymentData, Error>;
#[cfg(feature = "payouts")]
fn get_payout_method_data(&self) -> Result<api_models::payouts::PayoutMethodData, Error>;
#[cfg(feature = "payouts")]
fn get_quote_id(&self) -> Result<String, Error>;
fn get_optional_billing(&self) -> Option<&Address>;
fn get_optional_shipping(&self) -> Option<&Address>;
fn get_optional_shipping_line1(&self) -> Option<Secret<String>>;
fn get_optional_shipping_line2(&self) -> Option<Secret<String>>;
fn get_optional_shipping_city(&self) -> Option<String>;
fn get_optional_shipping_country(&self) -> Option<enums::CountryAlpha2>;
fn get_optional_shipping_zip(&self) -> Option<Secret<String>>;
fn get_optional_shipping_state(&self) -> Option<Secret<String>>;
fn get_optional_shipping_first_name(&self) -> Option<Secret<String>>;
fn get_optional_shipping_last_name(&self) -> Option<Secret<String>>;
fn get_optional_shipping_full_name(&self) -> Option<Secret<String>>;
fn get_optional_shipping_phone_number(&self) -> Option<Secret<String>>;
fn get_optional_shipping_email(&self) -> Option<Email>;
fn get_optional_billing_full_name(&self) -> Option<Secret<String>>;
fn get_optional_billing_line1(&self) -> Option<Secret<String>>;
fn get_optional_billing_line2(&self) -> Option<Secret<String>>;
fn get_optional_billing_city(&self) -> Option<String>;
fn get_optional_billing_country(&self) -> Option<enums::CountryAlpha2>;
fn get_optional_billing_zip(&self) -> Option<Secret<String>>;
fn get_optional_billing_state(&self) -> Option<Secret<String>>;
fn get_optional_billing_state_2_digit(&self) -> Option<Secret<String>>;
fn get_optional_billing_first_name(&self) -> Option<Secret<String>>;
fn get_optional_billing_last_name(&self) -> Option<Secret<String>>;
fn get_optional_billing_phone_number(&self) -> Option<Secret<String>>;
fn get_optional_billing_email(&self) -> Option<Email>;
}
<file_sep path="hyperswitch/crates/api_models/src/payment_methods.rs" role="context" start="2478" end="2478">
type Error = error_stack::Report<errors::ValidationError>;
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/paypal/transformers.rs<|crate|> hyperswitch_connectors<|connector|> paypal anchor=try_from kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paypal/transformers.rs" role="context" start="3116" end="3140">
fn try_from(req: &VerifyWebhookSourceRequestData) -> Result<Self, Self::Error> {
let req_body = serde_json::from_slice(&req.webhook_body)
.change_context(errors::ConnectorError::WebhookBodyDecodingFailed)?;
Ok(Self {
transmission_id: get_headers(
&req.webhook_headers,
webhook_headers::PAYPAL_TRANSMISSION_ID,
)
.change_context(errors::ConnectorError::WebhookSourceVerificationFailed)?,
transmission_time: get_headers(
&req.webhook_headers,
webhook_headers::PAYPAL_TRANSMISSION_TIME,
)?,
cert_url: get_headers(&req.webhook_headers, webhook_headers::PAYPAL_CERT_URL)?,
transmission_sig: get_headers(
&req.webhook_headers,
webhook_headers::PAYPAL_TRANSMISSION_SIG,
)?,
auth_algo: get_headers(&req.webhook_headers, webhook_headers::PAYPAL_AUTH_ALGO)?,
webhook_id: String::from_utf8(req.merchant_secret.secret.to_vec())
.change_context(errors::ConnectorError::WebhookVerificationSecretNotFound)
.attach_printable("Could not convert secret to UTF-8")?,
webhook_event: req_body,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paypal/transformers.rs" role="context" start="3115" end="3115">
use common_utils::{consts, errors::CustomResult, request::Method, types::StringMajorUnit};
use hyperswitch_domain_models::{
payment_method_data::{
BankDebitData, BankRedirectData, BankTransferData, CardRedirectData, GiftCardData,
PayLaterData, PaymentMethodData, VoucherData, WalletData,
},
router_data::{AccessToken, ConnectorAuthType, RouterData},
router_flow_types::{
payments::{Authorize, PostSessionTokens},
refunds::{Execute, RSync},
VerifyWebhookSource,
},
router_request_types::{
PaymentsAuthorizeData, PaymentsPostSessionTokensData, PaymentsSyncData, ResponseId,
VerifyWebhookSourceRequestData,
},
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
VerifyWebhookSourceResponseData, VerifyWebhookStatus,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCaptureRouterData,
PaymentsPostSessionTokensRouterData, RefreshTokenRouterData, RefundsRouterData,
SdkSessionUpdateRouterData, SetupMandateRouterData, VerifyWebhookSourceRouterData,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paypal/transformers.rs" role="context" start="3157" end="3162">
fn from(error: OrderErrorDetails) -> Self {
Self {
error_code: error.issue.to_string(),
error_message: error.issue.to_string(),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paypal/transformers.rs" role="context" start="3143" end="3154">
fn get_headers(
header: &actix_web::http::header::HeaderMap,
key: &'static str,
) -> CustomResult<String, errors::ConnectorError> {
let header_value = header
.get(key)
.map(|value| value.to_str())
.ok_or(errors::ConnectorError::MissingRequiredField { field_name: key })?
.change_context(errors::ConnectorError::InvalidDataFormat { field_name: key })?
.to_owned();
Ok(header_value)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paypal/transformers.rs" role="context" start="3092" end="3111">
fn try_from(event: PaypalWebhookEventType) -> Result<Self, Self::Error> {
match event {
PaypalWebhookEventType::PaymentCaptureCompleted
| PaypalWebhookEventType::CheckoutOrderCompleted => Ok(Self::Completed),
PaypalWebhookEventType::PaymentAuthorizationVoided => Ok(Self::Voided),
PaypalWebhookEventType::PaymentCapturePending
| PaypalWebhookEventType::CheckoutOrderProcessed => Ok(Self::Pending),
PaypalWebhookEventType::PaymentAuthorizationCreated => Ok(Self::Created),
PaypalWebhookEventType::CheckoutOrderApproved
| PaypalWebhookEventType::PaymentCaptureDeclined
| PaypalWebhookEventType::PaymentCaptureRefunded
| PaypalWebhookEventType::CustomerDisputeCreated
| PaypalWebhookEventType::CustomerDisputeResolved
| PaypalWebhookEventType::CustomerDisputedUpdated
| PaypalWebhookEventType::RiskDisputeCreated
| PaypalWebhookEventType::Unknown => {
Err(errors::ConnectorError::WebhookEventTypeNotFound.into())
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paypal/transformers.rs" role="context" start="3068" end="3087">
fn try_from(event: PaypalWebhookEventType) -> Result<Self, Self::Error> {
match event {
PaypalWebhookEventType::PaymentCaptureRefunded => Ok(Self::Completed),
PaypalWebhookEventType::PaymentAuthorizationCreated
| PaypalWebhookEventType::PaymentAuthorizationVoided
| PaypalWebhookEventType::PaymentCaptureDeclined
| PaypalWebhookEventType::PaymentCaptureCompleted
| PaypalWebhookEventType::PaymentCapturePending
| PaypalWebhookEventType::CheckoutOrderApproved
| PaypalWebhookEventType::CheckoutOrderCompleted
| PaypalWebhookEventType::CheckoutOrderProcessed
| PaypalWebhookEventType::CustomerDisputeCreated
| PaypalWebhookEventType::CustomerDisputeResolved
| PaypalWebhookEventType::CustomerDisputedUpdated
| PaypalWebhookEventType::RiskDisputeCreated
| PaypalWebhookEventType::Unknown => {
Err(errors::ConnectorError::WebhookEventTypeNotFound.into())
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paypal/transformers.rs" role="context" start="1896" end="1933">
fn foreign_try_from(
(item, payment_experience): (
ResponseRouterData<F, PaypalSyncResponse, PaymentsSyncData, PaymentsResponseData>,
Option<common_enums::PaymentExperience>,
),
) -> Result<Self, Self::Error> {
match item.response {
PaypalSyncResponse::PaypalOrdersSyncResponse(response) => {
Self::try_from(ResponseRouterData {
response,
data: item.data,
http_code: item.http_code,
})
}
PaypalSyncResponse::PaypalRedirectSyncResponse(response) => Self::foreign_try_from((
ResponseRouterData {
response,
data: item.data,
http_code: item.http_code,
},
payment_experience,
)),
PaypalSyncResponse::PaypalPaymentsSyncResponse(response) => {
Self::try_from(ResponseRouterData {
response,
data: item.data,
http_code: item.http_code,
})
}
PaypalSyncResponse::PaypalThreeDsSyncResponse(response) => {
Self::try_from(ResponseRouterData {
response,
data: item.data,
http_code: item.http_code,
})
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paypal/transformers.rs" role="context" start="799" end="855">
fn try_from(
item: &PaypalRouterData<&PaymentsPostSessionTokensRouterData>,
) -> Result<Self, Self::Error> {
let intent = if item.router_data.request.is_auto_capture()? {
PaypalPaymentIntent::Capture
} else {
PaypalPaymentIntent::Authorize
};
let paypal_auth: PaypalAuthType =
PaypalAuthType::try_from(&item.router_data.connector_auth_type)?;
let payee = get_payee(&paypal_auth);
let amount = OrderRequestAmount::try_from(item)?;
let connector_request_reference_id =
item.router_data.connector_request_reference_id.clone();
let shipping_address = ShippingAddress::from(item);
let item_details = vec![ItemDetails::try_from(item)?];
let purchase_units = vec![PurchaseUnitRequest {
reference_id: Some(connector_request_reference_id.clone()),
custom_id: item.router_data.request.merchant_order_reference_id.clone(),
invoice_id: Some(connector_request_reference_id),
amount,
payee,
shipping: Some(shipping_address),
items: item_details,
}];
let payment_source = Some(PaymentSourceItem::Paypal(
PaypalRedirectionRequest::PaypalRedirectionStruct(PaypalRedirectionStruct {
experience_context: ContextStruct {
return_url: item.router_data.request.router_return_url.clone(),
cancel_url: item.router_data.request.router_return_url.clone(),
shipping_preference: ShippingPreference::GetFromFile,
user_action: Some(UserAction::PayNow),
},
attributes: match item.router_data.request.setup_future_usage {
Some(setup_future_usage) => match setup_future_usage {
enums::FutureUsage::OffSession => Some(Attributes {
vault: PaypalVault {
store_in_vault: StoreInVault::OnSuccess,
usage_type: UsageType::Merchant,
},
}),
enums::FutureUsage::OnSession => None,
},
None => None,
},
}),
));
Ok(Self {
intent,
purchase_units,
payment_source,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paypal/transformers.rs" role="context" start="76" end="76">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/api_models/src/payment_methods.rs" role="context" start="2478" end="2478">
type Error = error_stack::Report<errors::ValidationError>;
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu/transformers.rs<|crate|> hyperswitch_connectors<|connector|> fiuu anchor=try_from kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu/transformers.rs" role="context" start="1700" end="1743">
fn try_from(
item: RefundsResponseRouterData<RSync, FiuuRefundSyncResponse>,
) -> Result<Self, Self::Error> {
match item.response {
FiuuRefundSyncResponse::Error(error) => Ok(Self {
response: Err(ErrorResponse {
code: error.error_code.clone(),
message: error.error_desc.clone(),
reason: Some(error.error_desc),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
}),
..item.data
}),
FiuuRefundSyncResponse::Success(refund_data) => {
let refund = refund_data
.iter()
.find(|refund| {
Some(refund.refund_id.clone()) == item.data.request.connector_refund_id
})
.ok_or_else(|| errors::ConnectorError::MissingConnectorRefundID)?;
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: refund.refund_id.clone(),
refund_status: enums::RefundStatus::from(refund.status.clone()),
}),
..item.data
})
}
FiuuRefundSyncResponse::Webhook(fiuu_webhooks_refund_response) => Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: fiuu_webhooks_refund_response.refund_id,
refund_status: enums::RefundStatus::from(
fiuu_webhooks_refund_response.status.clone(),
),
}),
..item.data
}),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu/transformers.rs" role="context" start="1699" end="1699">
use common_enums::{enums, BankNames, CaptureMethod, Currency};
use common_utils::{
crypto::{self, GenerateDigest},
errors::CustomResult,
ext_traits::Encode,
pii::Email,
request::Method,
types::{AmountConvertor, StringMajorUnit, StringMajorUnitForConnector},
};
use hyperswitch_domain_models::{
payment_method_data::{
BankRedirectData, Card, CardDetailsForNetworkTransactionId, GooglePayWalletData,
PaymentMethodData, RealTimePaymentData, WalletData,
},
router_data::{
ApplePayPredecryptData, ConnectorAuthType, ErrorResponse, PaymentMethodToken, RouterData,
},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{PaymentsAuthorizeData, ResponseId},
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsSyncRouterData, RefundSyncRouterData, RefundsRouterData,
},
};
use crate::{
constants,
types::{
PaymentsCancelResponseRouterData, PaymentsCaptureResponseRouterData,
PaymentsSyncResponseRouterData, RefundsResponseRouterData, ResponseRouterData,
},
unimplemented_payment_method,
utils::{
self, ApplePayDecrypt, PaymentsAuthorizeRequestData, QrImage, RefundsRequestData,
RouterData as _,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu/transformers.rs" role="context" start="1757" end="1783">
pub fn get_qr_metadata(
response: &DuitNowQrCodeResponse,
) -> CustomResult<Option<serde_json::Value>, errors::ConnectorError> {
let image_data = QrImage::new_colored_from_data(
response.txn_data.request_data.qr_data.peek().clone(),
constants::DUIT_NOW_BRAND_COLOR,
)
.change_context(errors::ConnectorError::ResponseHandlingFailed)?;
let image_data_url = Url::parse(image_data.data.clone().as_str()).ok();
let display_to_timestamp = None;
if let Some(color_image_data_url) = image_data_url {
let qr_code_info = payments::QrCodeInformation::QrColorDataUrl {
color_image_data_url,
display_to_timestamp,
display_text: Some(constants::DUIT_NOW_BRAND_TEXT.to_string()),
border_color: Some(constants::DUIT_NOW_BRAND_COLOR.to_string()),
};
Some(qr_code_info.encode_to_value())
.transpose()
.change_context(errors::ConnectorError::ResponseHandlingFailed)
} else {
Ok(None)
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu/transformers.rs" role="context" start="1747" end="1754">
fn from(item: RefundStatus) -> Self {
match item {
RefundStatus::Pending => Self::Pending,
RefundStatus::Success => Self::Success,
RefundStatus::Rejected => Self::Failure,
RefundStatus::Processing => Self::Pending,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu/transformers.rs" role="context" start="1654" end="1667">
fn try_from(item: &RefundSyncRouterData) -> Result<Self, Self::Error> {
let auth = FiuuAuthType::try_from(&item.connector_auth_type)?;
let (txn_id, merchant_id, verify_key) = (
item.request.connector_transaction_id.clone(),
auth.merchant_id.peek().to_string(),
auth.verify_key.peek().to_string(),
);
let signature = calculate_signature(format!("{txn_id}{merchant_id}{verify_key}"))?;
Ok(Self {
txn_id,
merchant_id: auth.merchant_id,
signature,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu/transformers.rs" role="context" start="1584" end="1638">
fn try_from(
item: PaymentsCancelResponseRouterData<FiuuPaymentCancelResponse>,
) -> Result<Self, Self::Error> {
let status_code = item.response.stat_code;
let status = match status_code.as_str() {
"00" => Ok(enums::AttemptStatus::Voided),
"11" | "12" | "13" | "14" | "15" | "16" | "17" | "18" | "19" | "20" | "21" => {
Ok(enums::AttemptStatus::VoidFailed)
}
other => Err(errors::ConnectorError::UnexpectedResponseError(
bytes::Bytes::from(other.to_owned()),
)),
}?;
let void_message_status = void_status_codes();
let error_response = if status == enums::AttemptStatus::VoidFailed {
Some(ErrorResponse {
status_code: item.http_code,
code: status_code.to_owned(),
message: void_message_status
.get(status_code.as_str())
.unwrap_or(&"NO_ERROR_MESSAGE")
.to_string(),
reason: Some(
void_message_status
.get(status_code.as_str())
.unwrap_or(&"NO_ERROR_REASON")
.to_string(),
),
attempt_status: None,
connector_transaction_id: Some(item.response.tran_id.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
} else {
None
};
let payments_response_data = PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
item.response.tran_id.clone().to_string(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
};
Ok(Self {
status,
response: error_response.map_or_else(|| Ok(payments_response_data), Err),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu/transformers.rs" role="context" start="204" end="245">
fn try_from(item: &FiuuRouterData<&PaymentsAuthorizeRouterData>) -> Result<Self, Self::Error> {
let auth: FiuuAuthType = FiuuAuthType::try_from(&item.router_data.connector_auth_type)?;
let record_type = FiuuRecordType::T;
let merchant_id = auth.merchant_id;
let order_id = item.router_data.connector_request_reference_id.clone();
let currency = item.router_data.request.currency;
let amount = item.amount.clone();
let billing_name = item
.router_data
.request
.get_card_holder_name_from_additional_payment_method_data()?;
let email = item.router_data.get_billing_email()?;
let token = Secret::new(item.router_data.request.get_connector_mandate_id()?);
let verify_key = auth.verify_key;
let recurring_request = FiuuRecurringRequest {
record_type: record_type.clone(),
merchant_id: merchant_id.clone(),
token: token.clone(),
order_id: order_id.clone(),
currency,
amount: amount.clone(),
billing_name: billing_name.clone(),
email: email.clone(),
verify_key: verify_key.clone(),
};
let check_sum = calculate_check_sum(recurring_request)?;
let mandate_request = format!(
"{}|{}||{}|{}|{}|{}|{}|{}|||{}",
record_type,
merchant_id.peek(),
token.peek(),
order_id,
currency,
amount.get_amount_as_string(),
billing_name.peek(),
email.peek(),
check_sum.peek()
);
Ok(Self {
mandate_request: mandate_request.into(),
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu/transformers.rs" role="context" start="1907" end="1913">
fn from(value: FiuuRefundsWebhookStatus) -> Self {
match value {
FiuuRefundsWebhookStatus::RefundFailure => Self::Failure,
FiuuRefundsWebhookStatus::RefundSuccess => Self::Success,
FiuuRefundsWebhookStatus::RefundPending => Self::Pending,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu/transformers.rs" role="context" start="77" end="77">
type Error = Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu/transformers.rs" role="context" start="1688" end="1693">
pub enum RefundStatus {
Success,
Pending,
Rejected,
Processing,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/aci/transformers.rs" role="context" start="642" end="642">
type Err = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/api_models/src/payment_methods.rs" role="context" start="2478" end="2478">
type Error = error_stack::Report<errors::ValidationError>;
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs<|crate|> hyperswitch_connectors<|connector|> adyen anchor=try_from kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="2948" end="3019">
fn try_from(
value: (
&AdyenRouterData<&PaymentsAuthorizeRouterData>,
&BankDebitData,
),
) -> Result<Self, Self::Error> {
let (item, bank_debit_data) = value;
let amount = get_amount_data(item);
let auth_type = AdyenAuthType::try_from(&item.router_data.connector_auth_type)?;
let shopper_interaction = AdyenShopperInteraction::from(item.router_data);
let (recurring_processing_model, store_payment_method, shopper_reference) =
get_recurring_processing_model(item.router_data)?;
let browser_info = get_browser_info(item.router_data)?;
let additional_data = get_additional_data(item.router_data);
let return_url = item.router_data.request.get_router_return_url()?;
let payment_method = PaymentMethod::AdyenPaymentMethod(Box::new(
AdyenPaymentMethod::try_from((bank_debit_data, item.router_data))?,
));
let country_code = get_country_code(item.router_data.get_optional_billing());
let (store, splits) = match item.router_data.request.split_payments.as_ref() {
Some(common_types::payments::SplitPaymentsRequest::AdyenSplitPayment(
adyen_split_payment,
)) => get_adyen_split_request(adyen_split_payment, item.router_data.request.currency),
_ => (None, None),
};
let device_fingerprint = item
.router_data
.request
.metadata
.clone()
.and_then(get_device_fingerprint);
let billing_address =
get_address_info(item.router_data.get_optional_billing()).and_then(Result::ok);
let delivery_address =
get_address_info(item.router_data.get_optional_shipping()).and_then(Result::ok);
let telephone_number = item.router_data.get_optional_billing_phone_number();
let request = AdyenPaymentRequest {
amount,
merchant_account: auth_type.merchant_account,
payment_method,
reference: item.router_data.connector_request_reference_id.clone(),
return_url,
browser_info,
shopper_interaction,
recurring_processing_model,
additional_data,
mpi_data: None,
shopper_name: None,
shopper_locale: None,
shopper_email: item.router_data.get_optional_billing_email(),
social_security_number: None,
telephone_number,
billing_address,
delivery_address,
country_code,
line_items: None,
shopper_reference,
store_payment_method,
channel: None,
shopper_statement: item.router_data.request.statement_descriptor.clone(),
shopper_ip: item.router_data.request.get_ip_address_as_optional(),
merchant_order_reference: item.router_data.request.merchant_order_reference_id.clone(),
store,
splits,
device_fingerprint,
};
Ok(request)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="2947" end="2947">
use api_models::{
enums,
payments::{self, QrCodeInformation, VoucherNextStepData},
};
use common_utils::{
errors::{CustomResult, ParsingError},
ext_traits::Encode,
pii::Email,
request::Method,
types::MinorUnit,
};
use hyperswitch_domain_models::{
network_tokenization::NetworkTokenNumber,
payment_method_data::{
BankDebitData, BankRedirectData, BankTransferData, Card, CardRedirectData, GiftCardData,
NetworkTokenData, PayLaterData, PaymentMethodData, VoucherData, WalletData,
},
router_data::{
ConnectorAuthType, ErrorResponse, PaymentMethodBalance, PaymentMethodToken, RouterData,
},
router_request_types::{PaymentsPreProcessingData, ResponseId, SubmitEvidenceRequestData},
router_response_types::{
AcceptDisputeResponse, DefendDisputeResponse, MandateReference, PaymentsResponseData,
RedirectForm, RefundsResponseData, SubmitEvidenceResponse,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsPreProcessingRouterData, RefundsRouterData,
},
};
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="3105" end="3170">
fn try_from(
value: (
&AdyenRouterData<&PaymentsAuthorizeRouterData>,
&BankTransferData,
),
) -> Result<Self, Self::Error> {
let (item, bank_transfer_data) = value;
let amount = get_amount_data(item);
let auth_type = AdyenAuthType::try_from(&item.router_data.connector_auth_type)?;
let shopper_interaction = AdyenShopperInteraction::from(item.router_data);
let payment_method = PaymentMethod::AdyenPaymentMethod(Box::new(
AdyenPaymentMethod::try_from((bank_transfer_data, item.router_data))?,
));
let return_url = item.router_data.request.get_router_return_url()?;
let (store, splits) = match item.router_data.request.split_payments.as_ref() {
Some(common_types::payments::SplitPaymentsRequest::AdyenSplitPayment(
adyen_split_payment,
)) => get_adyen_split_request(adyen_split_payment, item.router_data.request.currency),
_ => (None, None),
};
let device_fingerprint = item
.router_data
.request
.metadata
.clone()
.and_then(get_device_fingerprint);
let billing_address =
get_address_info(item.router_data.get_optional_billing()).and_then(Result::ok);
let delivery_address =
get_address_info(item.router_data.get_optional_shipping()).and_then(Result::ok);
let telephone_number = item.router_data.get_optional_billing_phone_number();
let request = AdyenPaymentRequest {
amount,
merchant_account: auth_type.merchant_account,
payment_method,
reference: item.router_data.connector_request_reference_id.to_string(),
return_url,
browser_info: None,
shopper_interaction,
recurring_processing_model: None,
additional_data: None,
mpi_data: None,
shopper_name: None,
shopper_locale: None,
shopper_email: item.router_data.get_optional_billing_email(),
social_security_number: None,
telephone_number,
billing_address,
delivery_address,
country_code: None,
line_items: None,
shopper_reference: None,
store_payment_method: None,
channel: None,
shopper_statement: item.router_data.request.statement_descriptor.clone(),
shopper_ip: item.router_data.request.get_ip_address_as_optional(),
merchant_order_reference: item.router_data.request.merchant_order_reference_id.clone(),
store,
splits,
device_fingerprint,
};
Ok(request)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="3027" end="3094">
fn try_from(
value: (&AdyenRouterData<&PaymentsAuthorizeRouterData>, &VoucherData),
) -> Result<Self, Self::Error> {
let (item, voucher_data) = value;
let amount = get_amount_data(item);
let auth_type = AdyenAuthType::try_from(&item.router_data.connector_auth_type)?;
let shopper_interaction = AdyenShopperInteraction::from(item.router_data);
let recurring_processing_model = get_recurring_processing_model(item.router_data)?.0;
let browser_info = get_browser_info(item.router_data)?;
let additional_data = get_additional_data(item.router_data);
let payment_method = PaymentMethod::AdyenPaymentMethod(Box::new(
AdyenPaymentMethod::try_from((voucher_data, item.router_data))?,
));
let return_url = item.router_data.request.get_router_return_url()?;
let social_security_number = get_social_security_number(voucher_data);
let billing_address =
get_address_info(item.router_data.get_optional_billing()).and_then(Result::ok);
let shopper_name = get_shopper_name(item.router_data.get_optional_billing());
let (store, splits) = match item.router_data.request.split_payments.as_ref() {
Some(common_types::payments::SplitPaymentsRequest::AdyenSplitPayment(
adyen_split_payment,
)) => get_adyen_split_request(adyen_split_payment, item.router_data.request.currency),
_ => (None, None),
};
let device_fingerprint = item
.router_data
.request
.metadata
.clone()
.and_then(get_device_fingerprint);
let delivery_address =
get_address_info(item.router_data.get_optional_shipping()).and_then(Result::ok);
let telephone_number = item.router_data.get_optional_billing_phone_number();
let request = AdyenPaymentRequest {
amount,
merchant_account: auth_type.merchant_account,
payment_method,
reference: item.router_data.connector_request_reference_id.to_string(),
return_url,
browser_info,
shopper_interaction,
recurring_processing_model,
additional_data,
shopper_name,
shopper_locale: None,
shopper_email: item.router_data.get_optional_billing_email(),
social_security_number,
mpi_data: None,
telephone_number,
billing_address,
delivery_address,
country_code: None,
line_items: None,
shopper_reference: None,
store_payment_method: None,
channel: None,
shopper_statement: item.router_data.request.statement_descriptor.clone(),
shopper_ip: item.router_data.request.get_ip_address_as_optional(),
merchant_order_reference: item.router_data.request.merchant_order_reference_id.clone(),
store,
splits,
device_fingerprint,
};
Ok(request)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="2863" end="2937">
fn try_from(
value: (&AdyenRouterData<&PaymentsAuthorizeRouterData>, &Card),
) -> Result<Self, Self::Error> {
let (item, card_data) = value;
let amount = get_amount_data(item);
let auth_type = AdyenAuthType::try_from(&item.router_data.connector_auth_type)?;
let shopper_interaction = AdyenShopperInteraction::from(item.router_data);
let shopper_reference = build_shopper_reference(
&item.router_data.customer_id,
item.router_data.merchant_id.clone(),
);
let (recurring_processing_model, store_payment_method, _) =
get_recurring_processing_model(item.router_data)?;
let browser_info = get_browser_info(item.router_data)?;
let billing_address =
get_address_info(item.router_data.get_optional_billing()).and_then(Result::ok);
let country_code = get_country_code(item.router_data.get_optional_billing());
let additional_data = get_additional_data(item.router_data);
let return_url = item.router_data.request.get_router_return_url()?;
let card_holder_name = item.router_data.get_optional_billing_full_name();
let payment_method = PaymentMethod::AdyenPaymentMethod(Box::new(
AdyenPaymentMethod::try_from((card_data, card_holder_name))?,
));
let shopper_email = item.router_data.get_optional_billing_email();
let shopper_name = get_shopper_name(item.router_data.get_optional_billing());
let (store, splits) = match item.router_data.request.split_payments.as_ref() {
Some(common_types::payments::SplitPaymentsRequest::AdyenSplitPayment(
adyen_split_payment,
)) => get_adyen_split_request(adyen_split_payment, item.router_data.request.currency),
_ => (None, None),
};
let device_fingerprint = item
.router_data
.request
.metadata
.clone()
.and_then(get_device_fingerprint);
let delivery_address =
get_address_info(item.router_data.get_optional_shipping()).and_then(Result::ok);
let telephone_number = item.router_data.get_optional_billing_phone_number();
Ok(AdyenPaymentRequest {
amount,
merchant_account: auth_type.merchant_account,
payment_method,
reference: item.router_data.connector_request_reference_id.clone(),
return_url,
shopper_interaction,
recurring_processing_model,
browser_info,
additional_data,
mpi_data: None,
telephone_number,
shopper_name,
shopper_email,
shopper_locale: None,
social_security_number: None,
billing_address,
delivery_address,
country_code,
line_items: None,
shopper_reference,
store_payment_method,
channel: None,
shopper_statement: item.router_data.request.statement_descriptor.clone(),
shopper_ip: item.router_data.request.get_ip_address_as_optional(),
merchant_order_reference: item.router_data.request.merchant_order_reference_id.clone(),
store,
splits,
device_fingerprint,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="2671" end="2859">
fn try_from(
value: (
&AdyenRouterData<&PaymentsAuthorizeRouterData>,
payments::MandateReferenceId,
),
) -> Result<Self, Self::Error> {
let (item, mandate_ref_id) = value;
let amount = get_amount_data(item);
let auth_type = AdyenAuthType::try_from(&item.router_data.connector_auth_type)?;
let shopper_interaction = AdyenShopperInteraction::from(item.router_data);
let (recurring_processing_model, store_payment_method, shopper_reference) =
get_recurring_processing_model(item.router_data)?;
let browser_info = None;
let additional_data = get_additional_data(item.router_data);
let return_url = item.router_data.request.get_router_return_url()?;
let payment_method_type = item.router_data.request.payment_method_type;
let payment_method = match mandate_ref_id {
payments::MandateReferenceId::ConnectorMandateId(connector_mandate_ids) => {
let adyen_mandate = AdyenMandate {
payment_type: match payment_method_type {
Some(pm_type) => PaymentType::try_from(&pm_type)?,
None => PaymentType::Scheme,
},
stored_payment_method_id: Secret::new(
connector_mandate_ids
.get_connector_mandate_id()
.ok_or_else(missing_field_err("mandate_id"))?,
),
};
Ok::<PaymentMethod<'_>, Self::Error>(PaymentMethod::AdyenMandatePaymentMethod(
Box::new(adyen_mandate),
))
}
payments::MandateReferenceId::NetworkMandateId(network_mandate_id) => {
match item.router_data.request.payment_method_data {
PaymentMethodData::CardDetailsForNetworkTransactionId(
ref card_details_for_network_transaction_id,
) => {
let brand = match card_details_for_network_transaction_id
.card_network
.clone()
.and_then(get_adyen_card_network)
{
Some(card_network) => card_network,
None => CardBrand::try_from(
&card_details_for_network_transaction_id.get_card_issuer()?,
)?,
};
let card_holder_name = item.router_data.get_optional_billing_full_name();
let adyen_card = AdyenCard {
number: card_details_for_network_transaction_id.card_number.clone(),
expiry_month: card_details_for_network_transaction_id
.card_exp_month
.clone(),
expiry_year: card_details_for_network_transaction_id
.get_expiry_year_4_digit()
.clone(),
cvc: None,
holder_name: card_holder_name,
brand: Some(brand),
network_payment_reference: Some(Secret::new(network_mandate_id)),
};
Ok(PaymentMethod::AdyenPaymentMethod(Box::new(
AdyenPaymentMethod::AdyenCard(Box::new(adyen_card)),
)))
}
PaymentMethodData::CardRedirect(_)
| PaymentMethodData::Wallet(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::Card(_) => Err(errors::ConnectorError::NotSupported {
message: "Network tokenization for payment method".to_string(),
connector: "Adyen",
})?,
}
}
payments::MandateReferenceId::NetworkTokenWithNTI(network_mandate_id) => {
match item.router_data.request.payment_method_data {
PaymentMethodData::NetworkToken(ref token_data) => {
let card_issuer = token_data.get_card_issuer()?;
let brand = CardBrand::try_from(&card_issuer)?;
let card_holder_name = item.router_data.get_optional_billing_full_name();
let adyen_network_token = AdyenNetworkTokenData {
number: token_data.get_network_token(),
expiry_month: token_data.get_network_token_expiry_month(),
expiry_year: token_data.get_expiry_year_4_digit(),
holder_name: card_holder_name,
brand: Some(brand), // FIXME: Remove hardcoding
network_payment_reference: Some(Secret::new(
network_mandate_id.network_transaction_id,
)),
};
Ok(PaymentMethod::AdyenPaymentMethod(Box::new(
AdyenPaymentMethod::NetworkToken(Box::new(adyen_network_token)),
)))
}
PaymentMethodData::Card(_)
| PaymentMethodData::CardRedirect(_)
| PaymentMethodData::Wallet(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {
Err(errors::ConnectorError::NotSupported {
message: "Network tokenization for payment method".to_string(),
connector: "Adyen",
})?
}
}
} //
}?;
let (store, splits) = match item.router_data.request.split_payments.as_ref() {
Some(common_types::payments::SplitPaymentsRequest::AdyenSplitPayment(
adyen_split_payment,
)) => get_adyen_split_request(adyen_split_payment, item.router_data.request.currency),
_ => (None, None),
};
let device_fingerprint = item
.router_data
.request
.metadata
.clone()
.and_then(get_device_fingerprint);
let billing_address =
get_address_info(item.router_data.get_optional_billing()).and_then(Result::ok);
let delivery_address =
get_address_info(item.router_data.get_optional_shipping()).and_then(Result::ok);
let telephone_number = item.router_data.get_optional_billing_phone_number();
Ok(AdyenPaymentRequest {
amount,
merchant_account: auth_type.merchant_account,
payment_method,
reference: item.router_data.connector_request_reference_id.clone(),
return_url,
shopper_interaction,
recurring_processing_model,
browser_info,
additional_data,
mpi_data: None,
telephone_number,
shopper_name: None,
shopper_email: None,
shopper_locale: None,
social_security_number: None,
billing_address,
delivery_address,
country_code: None,
line_items: None,
shopper_reference,
store_payment_method,
channel: None,
shopper_statement: item.router_data.request.statement_descriptor.clone(),
shopper_ip: item.router_data.request.get_ip_address_as_optional(),
merchant_order_reference: item.router_data.request.merchant_order_reference_id.clone(),
store,
splits,
device_fingerprint,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="1797" end="1818">
fn get_browser_info(item: &PaymentsAuthorizeRouterData) -> Result<Option<AdyenBrowserInfo>, Error> {
if item.auth_type == storage_enums::AuthenticationType::ThreeDs
|| item.payment_method == storage_enums::PaymentMethod::Card
|| item.payment_method == storage_enums::PaymentMethod::BankRedirect
|| item.request.payment_method_type == Some(storage_enums::PaymentMethodType::GoPay)
|| item.request.payment_method_type == Some(storage_enums::PaymentMethodType::GooglePay)
{
let info = item.request.get_browser_info()?;
Ok(Some(AdyenBrowserInfo {
accept_header: info.get_accept_header()?,
language: info.get_language()?,
screen_height: info.get_screen_height()?,
screen_width: info.get_screen_width()?,
color_depth: info.get_color_depth()?,
user_agent: info.get_user_agent()?,
time_zone_offset: info.get_time_zone()?,
java_enabled: info.get_java_enabled()?,
}))
} else {
Ok(None)
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="3634" end="3653">
fn get_adyen_split_request(
split_request: &common_types::domain::AdyenSplitData,
currency: common_enums::enums::Currency,
) -> (Option<String>, Option<Vec<AdyenSplitData>>) {
let splits = split_request
.split_items
.iter()
.map(|split_item| {
let amount = split_item.amount.map(|value| Amount { currency, value });
AdyenSplitData {
amount,
reference: split_item.reference.clone(),
split_type: split_item.split_type.clone(),
account: split_item.account.clone(),
description: split_item.description.clone(),
}
})
.collect();
(split_request.store.clone(), Some(splits))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="66" end="66">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="1384" end="1389">
pub struct AdyenAuthType {
pub(super) api_key: Secret<String>,
pub(super) merchant_account: Secret<String>,
#[allow(dead_code)]
pub(super) review_key: Option<Secret<String>>,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/worldpay/requests.rs" role="context" start="288" end="293">
pub enum PaymentMethod {
#[default]
Card,
ApplePay,
GooglePay,
}
<file_sep path="hyperswitch/v2_compatible_migrations/2024-08-28-081721_add_v2_columns/up.sql" role="context" start="54" end="70">
ADD COLUMN redirection_data JSONB,
ADD COLUMN connector_payment_data TEXT,
ADD COLUMN connector_token_details JSONB;
-- Change the type of the column from JSON to JSONB
ALTER TABLE merchant_connector_account
ADD COLUMN IF NOT EXISTS feature_metadata JSONB;
ALTER TABLE payment_methods
ADD COLUMN IF NOT EXISTS locker_fingerprint_id VARCHAR(64),
ADD COLUMN IF NOT EXISTS payment_method_type_v2 VARCHAR(64),
ADD COLUMN IF NOT EXISTS payment_method_subtype VARCHAR(64);
ALTER TABLE refund
ADD COLUMN IF NOT EXISTS id VARCHAR(64),
ADD COLUMN IF NOT EXISTS merchant_reference_id VARCHAR(64),
ADD COLUMN IF NOT EXISTS connector_id VARCHAR(64);
<file_sep path="hyperswitch/crates/api_models/src/payment_methods.rs" role="context" start="2478" end="2478">
type Error = error_stack::Report<errors::ValidationError>;
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree.rs<|crate|> hyperswitch_connectors<|connector|> braintree anchor=get_url kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree.rs" role="context" start="1164" end="1170">
fn get_url(
&self,
_req: &PaymentsCompleteAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(self.base_url(connectors).to_string())
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree.rs" role="context" start="1163" end="1163">
for Braintree
{
fn get_headers(
&self,
req: &PaymentsCompleteAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
&self,
_req: &PaymentsCompleteAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(self.base_url(connectors).to_string())
}
fn get_request_body(
&self,
req: &PaymentsCompleteAuthorizeRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let amount = convert_amount(
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree.rs" role="context" start="1188" end="1208">
fn build_request(
&self,
req: &PaymentsCompleteAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&PaymentsCompleteAuthorizeType::get_url(
self, req, connectors,
)?)
.attach_default_headers()
.headers(PaymentsCompleteAuthorizeType::get_headers(
self, req, connectors,
)?)
.set_body(PaymentsCompleteAuthorizeType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree.rs" role="context" start="1171" end="1186">
fn get_request_body(
&self,
req: &PaymentsCompleteAuthorizeRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let amount = convert_amount(
self.amount_converter,
req.request.minor_amount,
req.request.currency,
)?;
let connector_router_data = braintree::BraintreeRouterData::try_from((amount, req))?;
let connector_req =
transformers::BraintreePaymentsRequest::try_from(&connector_router_data)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree.rs" role="context" start="1161" end="1163">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree.rs" role="context" start="1154" end="1160">
fn get_headers(
&self,
req: &PaymentsCompleteAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree.rs" role="context" start="462" end="476">
fn build_request(
&self,
req: &PaymentsSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&PaymentsSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(PaymentsSyncType::get_headers(self, req, connectors)?)
.set_body(PaymentsSyncType::get_request_body(self, req, connectors)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree.rs" role="context" start="693" end="707">
fn build_request(
&self,
req: &PaymentsCancelRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&PaymentsVoidType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(PaymentsVoidType::get_headers(self, req, connectors)?)
.set_body(PaymentsVoidType::get_request_body(self, req, connectors)?)
.build(),
))
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/wellsfargo.rs<|crate|> hyperswitch_connectors<|connector|> wellsfargo anchor=get_headers kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/wellsfargo.rs" role="context" start="1204" end="1210">
fn get_headers(
&self,
req: &PaymentsIncrementalAuthorizationRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/wellsfargo.rs" role="context" start="1203" end="1203">
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
}
impl
ConnectorIntegration<
IncrementalAuthorization,
PaymentsIncrementalAuthorizationData,
PaymentsResponseData,
> for Wellsfargo
{
fn get_headers(
&self,
req: &PaymentsIncrementalAuthorizationRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
fn get_http_method(&self) -> Method {
Method::Patch
}
fn get_content_type(&self) -> &'static str {
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/wellsfargo.rs" role="context" start="1216" end="1218">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/wellsfargo.rs" role="context" start="1212" end="1214">
fn get_http_method(&self) -> Method {
Method::Patch
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/wellsfargo.rs" role="context" start="1188" end="1194">
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/wellsfargo.rs" role="context" start="1170" end="1187">
fn handle_response(
&self,
data: &RefundSyncRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundSyncRouterData, errors::ConnectorError> {
let response: wellsfargo::WellsfargoRsyncResponse = res
.response
.parse_struct("Wellsfargo RefundSyncResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/wellsfargo.rs" role="context" start="528" end="541">
fn build_request(
&self,
req: &MandateRevokeRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Delete)
.url(&MandateRevokeType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(MandateRevokeType::get_headers(self, req, connectors)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/wellsfargo.rs" role="context" start="1156" end="1169">
fn build_request(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&RefundSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(RefundSyncType::get_headers(self, req, connectors)?)
.build(),
))
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree.rs<|crate|> hyperswitch_connectors<|connector|> braintree anchor=get_headers kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree.rs" role="context" start="1154" end="1160">
fn get_headers(
&self,
req: &PaymentsCompleteAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree.rs" role="context" start="1153" end="1153">
},
PaymentAction::CompleteAuthorize
| PaymentAction::PaymentAuthenticateCompleteAuthorize => {
Ok(CallConnectorAction::Trigger)
}
}
}
}
impl ConnectorIntegration<CompleteAuthorize, CompleteAuthorizeData, PaymentsResponseData>
for Braintree
{
fn get_headers(
&self,
req: &PaymentsCompleteAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
&self,
_req: &PaymentsCompleteAuthorizeRouterData,
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree.rs" role="context" start="1164" end="1170">
fn get_url(
&self,
_req: &PaymentsCompleteAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(self.base_url(connectors).to_string())
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree.rs" role="context" start="1161" end="1163">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree.rs" role="context" start="1106" end="1148">
fn get_flow_type(
&self,
_query_params: &str,
json_payload: Option<serde_json::Value>,
action: PaymentAction,
) -> CustomResult<CallConnectorAction, errors::ConnectorError> {
match action {
PaymentAction::PSync => match json_payload {
Some(payload) => {
let redirection_response: transformers::BraintreeRedirectionResponse =
serde_json::from_value(payload).change_context(
errors::ConnectorError::MissingConnectorRedirectionPayload {
field_name: "redirection_response",
},
)?;
let braintree_payload =
serde_json::from_str::<transformers::BraintreeThreeDsErrorResponse>(
&redirection_response.authentication_response,
);
let (error_code, error_message) = match braintree_payload {
Ok(braintree_response_payload) => (
braintree_response_payload.code,
braintree_response_payload.message,
),
Err(_) => (
NO_ERROR_CODE.to_string(),
redirection_response.authentication_response,
),
};
Ok(CallConnectorAction::StatusUpdate {
status: enums::AttemptStatus::AuthenticationFailed,
error_code: Some(error_code),
error_message: Some(error_message),
})
}
None => Ok(CallConnectorAction::Avoid),
},
PaymentAction::CompleteAuthorize
| PaymentAction::PaymentAuthenticateCompleteAuthorize => {
Ok(CallConnectorAction::Trigger)
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree.rs" role="context" start="1090" end="1103">
fn decode_webhook_payload(
payload: &[u8],
) -> CustomResult<transformers::Notification, errors::ConnectorError> {
let decoded_response = BASE64_ENGINE
.decode(payload)
.change_context(errors::ConnectorError::WebhookBodyDecodingFailed)?;
let xml_response = String::from_utf8(decoded_response)
.change_context(errors::ConnectorError::WebhookBodyDecodingFailed)?;
xml_response
.parse_xml::<transformers::Notification>()
.change_context(errors::ConnectorError::WebhookBodyDecodingFailed)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree.rs" role="context" start="462" end="476">
fn build_request(
&self,
req: &PaymentsSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&PaymentsSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(PaymentsSyncType::get_headers(self, req, connectors)?)
.set_body(PaymentsSyncType::get_request_body(self, req, connectors)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree.rs" role="context" start="693" end="707">
fn build_request(
&self,
req: &PaymentsCancelRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&PaymentsVoidType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(PaymentsVoidType::get_headers(self, req, connectors)?)
.set_body(PaymentsVoidType::get_request_body(self, req, connectors)?)
.build(),
))
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/nexixpay.rs<|crate|> hyperswitch_connectors<|connector|> nexixpay anchor=get_headers kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexixpay.rs" role="context" start="983" end="989">
fn get_headers(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexixpay.rs" role="context" start="982" end="982">
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
}
impl ConnectorIntegration<RSync, RefundsData, RefundsResponseData> for Nexixpay {
fn get_headers(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexixpay.rs" role="context" start="995" end="1006">
fn get_url(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let connector_refund_id = req.request.get_connector_refund_id()?;
Ok(format!(
"{}/operations/{}",
self.base_url(connectors),
connector_refund_id
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexixpay.rs" role="context" start="991" end="993">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexixpay.rs" role="context" start="973" end="979">
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexixpay.rs" role="context" start="954" end="971">
fn handle_response(
&self,
data: &RefundsRouterData<Execute>,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundsRouterData<Execute>, errors::ConnectorError> {
let response: nexixpay::RefundResponse = res
.response
.parse_struct("RefundResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexixpay.rs" role="context" start="446" end="466">
fn build_request(
&self,
req: &PaymentsCompleteAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsCompleteAuthorizeType::get_url(
self, req, connectors,
)?)
.attach_default_headers()
.headers(types::PaymentsCompleteAuthorizeType::get_headers(
self, req, connectors,
)?)
.set_body(types::PaymentsCompleteAuthorizeType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexixpay.rs" role="context" start="354" end="374">
fn build_request(
&self,
req: &PaymentsPreProcessingRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsPreProcessingType::get_url(
self, req, connectors,
)?)
.attach_default_headers()
.headers(types::PaymentsPreProcessingType::get_headers(
self, req, connectors,
)?)
.set_body(types::PaymentsPreProcessingType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/payme.rs<|crate|> hyperswitch_connectors<|connector|> payme anchor=get_headers kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payme.rs" role="context" start="1002" end="1008">
fn get_headers(
&self,
req: &RouterData<RSync, RefundsData, RefundsResponseData>,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payme.rs" role="context" start="1001" end="1001">
}
}
impl ConnectorIntegration<RSync, RefundsData, RefundsResponseData> for Payme {
fn get_url(
&self,
_req: &RouterData<RSync, RefundsData, RefundsResponseData>,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}api/get-transactions", self.base_url(connectors)))
}
fn get_headers(
&self,
req: &RouterData<RSync, RefundsData, RefundsResponseData>,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_request_body(
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payme.rs" role="context" start="1014" end="1021">
fn get_request_body(
&self,
req: &RouterData<RSync, RefundsData, RefundsResponseData>,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let connector_req = payme::PaymeQueryTransactionRequest::try_from(req)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payme.rs" role="context" start="1010" end="1012">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payme.rs" role="context" start="994" end="1000">
fn get_url(
&self,
_req: &RouterData<RSync, RefundsData, RefundsResponseData>,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}api/get-transactions", self.base_url(connectors)))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payme.rs" role="context" start="983" end="990">
fn get_5xx_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
// we are always getting 500 in error scenarios
self.build_error_response(res, event_builder)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payme.rs" role="context" start="656" end="670">
fn build_request(
&self,
req: &RouterData<PSync, PaymentsSyncData, PaymentsResponseData>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&PaymentsSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(PaymentsSyncType::get_headers(self, req, connectors)?)
.set_body(PaymentsSyncType::get_request_body(self, req, connectors)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payme.rs" role="context" start="569" end="585">
fn build_request(
&self,
req: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&PaymentsAuthorizeType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(PaymentsAuthorizeType::get_headers(self, req, connectors)?)
.set_body(PaymentsAuthorizeType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/utils.rs" role="context" start="455" end="516">
pub trait RouterData {
fn get_billing(&self) -> Result<&Address, Error>;
fn get_billing_country(&self) -> Result<api_models::enums::CountryAlpha2, Error>;
fn get_billing_phone(&self) -> Result<&PhoneDetails, Error>;
fn get_description(&self) -> Result<String, Error>;
fn get_billing_address(&self) -> Result<&AddressDetails, Error>;
fn get_shipping_address(&self) -> Result<&AddressDetails, Error>;
fn get_shipping_address_with_phone_number(&self) -> Result<&Address, Error>;
fn get_connector_meta(&self) -> Result<pii::SecretSerdeValue, Error>;
fn get_session_token(&self) -> Result<String, Error>;
fn get_billing_first_name(&self) -> Result<Secret<String>, Error>;
fn get_billing_full_name(&self) -> Result<Secret<String>, Error>;
fn get_billing_last_name(&self) -> Result<Secret<String>, Error>;
fn get_billing_line1(&self) -> Result<Secret<String>, Error>;
fn get_billing_line2(&self) -> Result<Secret<String>, Error>;
fn get_billing_zip(&self) -> Result<Secret<String>, Error>;
fn get_billing_state(&self) -> Result<Secret<String>, Error>;
fn get_billing_state_code(&self) -> Result<Secret<String>, Error>;
fn get_billing_city(&self) -> Result<String, Error>;
fn get_billing_email(&self) -> Result<Email, Error>;
fn get_billing_phone_number(&self) -> Result<Secret<String>, Error>;
fn to_connector_meta<T>(&self) -> Result<T, Error>
where
T: serde::de::DeserializeOwned;
fn is_three_ds(&self) -> bool;
fn get_payment_method_token(&self) -> Result<PaymentMethodToken, Error>;
fn get_customer_id(&self) -> Result<id_type::CustomerId, Error>;
fn get_connector_customer_id(&self) -> Result<String, Error>;
fn get_preprocessing_id(&self) -> Result<String, Error>;
fn get_recurring_mandate_payment_data(&self) -> Result<RecurringMandatePaymentData, Error>;
#[cfg(feature = "payouts")]
fn get_payout_method_data(&self) -> Result<api_models::payouts::PayoutMethodData, Error>;
#[cfg(feature = "payouts")]
fn get_quote_id(&self) -> Result<String, Error>;
fn get_optional_billing(&self) -> Option<&Address>;
fn get_optional_shipping(&self) -> Option<&Address>;
fn get_optional_shipping_line1(&self) -> Option<Secret<String>>;
fn get_optional_shipping_line2(&self) -> Option<Secret<String>>;
fn get_optional_shipping_city(&self) -> Option<String>;
fn get_optional_shipping_country(&self) -> Option<enums::CountryAlpha2>;
fn get_optional_shipping_zip(&self) -> Option<Secret<String>>;
fn get_optional_shipping_state(&self) -> Option<Secret<String>>;
fn get_optional_shipping_first_name(&self) -> Option<Secret<String>>;
fn get_optional_shipping_last_name(&self) -> Option<Secret<String>>;
fn get_optional_shipping_full_name(&self) -> Option<Secret<String>>;
fn get_optional_shipping_phone_number(&self) -> Option<Secret<String>>;
fn get_optional_shipping_email(&self) -> Option<Email>;
fn get_optional_billing_full_name(&self) -> Option<Secret<String>>;
fn get_optional_billing_line1(&self) -> Option<Secret<String>>;
fn get_optional_billing_line2(&self) -> Option<Secret<String>>;
fn get_optional_billing_city(&self) -> Option<String>;
fn get_optional_billing_country(&self) -> Option<enums::CountryAlpha2>;
fn get_optional_billing_zip(&self) -> Option<Secret<String>>;
fn get_optional_billing_state(&self) -> Option<Secret<String>>;
fn get_optional_billing_state_2_digit(&self) -> Option<Secret<String>>;
fn get_optional_billing_first_name(&self) -> Option<Secret<String>>;
fn get_optional_billing_last_name(&self) -> Option<Secret<String>>;
fn get_optional_billing_phone_number(&self) -> Option<Secret<String>>;
fn get_optional_billing_email(&self) -> Option<Email>;
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/payme.rs<|crate|> hyperswitch_connectors<|connector|> payme anchor=get_url kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payme.rs" role="context" start="994" end="1000">
fn get_url(
&self,
_req: &RouterData<RSync, RefundsData, RefundsResponseData>,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}api/get-transactions", self.base_url(connectors)))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payme.rs" role="context" start="993" end="993">
fn get_5xx_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
// we are always getting 500 in error scenarios
self.build_error_response(res, event_builder)
}
}
impl ConnectorIntegration<RSync, RefundsData, RefundsResponseData> for Payme {
fn get_url(
&self,
_req: &RouterData<RSync, RefundsData, RefundsResponseData>,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}api/get-transactions", self.base_url(connectors)))
}
fn get_headers(
&self,
req: &RouterData<RSync, RefundsData, RefundsResponseData>,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payme.rs" role="context" start="1010" end="1012">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payme.rs" role="context" start="1002" end="1008">
fn get_headers(
&self,
req: &RouterData<RSync, RefundsData, RefundsResponseData>,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payme.rs" role="context" start="983" end="990">
fn get_5xx_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
// we are always getting 500 in error scenarios
self.build_error_response(res, event_builder)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payme.rs" role="context" start="975" end="981">
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payme.rs" role="context" start="1023" end="1036">
fn build_request(
&self,
req: &RouterData<RSync, RefundsData, RefundsResponseData>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Post)
.url(&RefundSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(RefundSyncType::get_headers(self, req, connectors)?)
.set_body(RefundSyncType::get_request_body(self, req, connectors)?)
.build();
Ok(Some(request))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payme.rs" role="context" start="334" end="353">
fn build_request(
&self,
req: &PaymentsPreProcessingRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let req = Some(
RequestBuilder::new()
.method(Method::Post)
.attach_default_headers()
.headers(PaymentsPreProcessingType::get_headers(
self, req, connectors,
)?)
.url(&PaymentsPreProcessingType::get_url(self, req, connectors)?)
.set_body(PaymentsPreProcessingType::get_request_body(
self, req, connectors,
)?)
.build(),
);
Ok(req)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/utils.rs" role="context" start="455" end="516">
pub trait RouterData {
fn get_billing(&self) -> Result<&Address, Error>;
fn get_billing_country(&self) -> Result<api_models::enums::CountryAlpha2, Error>;
fn get_billing_phone(&self) -> Result<&PhoneDetails, Error>;
fn get_description(&self) -> Result<String, Error>;
fn get_billing_address(&self) -> Result<&AddressDetails, Error>;
fn get_shipping_address(&self) -> Result<&AddressDetails, Error>;
fn get_shipping_address_with_phone_number(&self) -> Result<&Address, Error>;
fn get_connector_meta(&self) -> Result<pii::SecretSerdeValue, Error>;
fn get_session_token(&self) -> Result<String, Error>;
fn get_billing_first_name(&self) -> Result<Secret<String>, Error>;
fn get_billing_full_name(&self) -> Result<Secret<String>, Error>;
fn get_billing_last_name(&self) -> Result<Secret<String>, Error>;
fn get_billing_line1(&self) -> Result<Secret<String>, Error>;
fn get_billing_line2(&self) -> Result<Secret<String>, Error>;
fn get_billing_zip(&self) -> Result<Secret<String>, Error>;
fn get_billing_state(&self) -> Result<Secret<String>, Error>;
fn get_billing_state_code(&self) -> Result<Secret<String>, Error>;
fn get_billing_city(&self) -> Result<String, Error>;
fn get_billing_email(&self) -> Result<Email, Error>;
fn get_billing_phone_number(&self) -> Result<Secret<String>, Error>;
fn to_connector_meta<T>(&self) -> Result<T, Error>
where
T: serde::de::DeserializeOwned;
fn is_three_ds(&self) -> bool;
fn get_payment_method_token(&self) -> Result<PaymentMethodToken, Error>;
fn get_customer_id(&self) -> Result<id_type::CustomerId, Error>;
fn get_connector_customer_id(&self) -> Result<String, Error>;
fn get_preprocessing_id(&self) -> Result<String, Error>;
fn get_recurring_mandate_payment_data(&self) -> Result<RecurringMandatePaymentData, Error>;
#[cfg(feature = "payouts")]
fn get_payout_method_data(&self) -> Result<api_models::payouts::PayoutMethodData, Error>;
#[cfg(feature = "payouts")]
fn get_quote_id(&self) -> Result<String, Error>;
fn get_optional_billing(&self) -> Option<&Address>;
fn get_optional_shipping(&self) -> Option<&Address>;
fn get_optional_shipping_line1(&self) -> Option<Secret<String>>;
fn get_optional_shipping_line2(&self) -> Option<Secret<String>>;
fn get_optional_shipping_city(&self) -> Option<String>;
fn get_optional_shipping_country(&self) -> Option<enums::CountryAlpha2>;
fn get_optional_shipping_zip(&self) -> Option<Secret<String>>;
fn get_optional_shipping_state(&self) -> Option<Secret<String>>;
fn get_optional_shipping_first_name(&self) -> Option<Secret<String>>;
fn get_optional_shipping_last_name(&self) -> Option<Secret<String>>;
fn get_optional_shipping_full_name(&self) -> Option<Secret<String>>;
fn get_optional_shipping_phone_number(&self) -> Option<Secret<String>>;
fn get_optional_shipping_email(&self) -> Option<Email>;
fn get_optional_billing_full_name(&self) -> Option<Secret<String>>;
fn get_optional_billing_line1(&self) -> Option<Secret<String>>;
fn get_optional_billing_line2(&self) -> Option<Secret<String>>;
fn get_optional_billing_city(&self) -> Option<String>;
fn get_optional_billing_country(&self) -> Option<enums::CountryAlpha2>;
fn get_optional_billing_zip(&self) -> Option<Secret<String>>;
fn get_optional_billing_state(&self) -> Option<Secret<String>>;
fn get_optional_billing_state_2_digit(&self) -> Option<Secret<String>>;
fn get_optional_billing_first_name(&self) -> Option<Secret<String>>;
fn get_optional_billing_last_name(&self) -> Option<Secret<String>>;
fn get_optional_billing_phone_number(&self) -> Option<Secret<String>>;
fn get_optional_billing_email(&self) -> Option<Email>;
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/nexixpay.rs<|crate|> hyperswitch_connectors<|connector|> nexixpay anchor=get_url kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexixpay.rs" role="context" start="995" end="1006">
fn get_url(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let connector_refund_id = req.request.get_connector_refund_id()?;
Ok(format!(
"{}/operations/{}",
self.base_url(connectors),
connector_refund_id
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexixpay.rs" role="context" start="994" end="994">
fn get_headers(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let connector_refund_id = req.request.get_connector_refund_id()?;
Ok(format!(
"{}/operations/{}",
self.base_url(connectors),
connector_refund_id
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexixpay.rs" role="context" start="1026" end="1043">
fn handle_response(
&self,
data: &RefundSyncRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundSyncRouterData, errors::ConnectorError> {
let response: nexixpay::NexixpayRSyncResponse = res
.response
.parse_struct("NexixpayRSyncResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexixpay.rs" role="context" start="1008" end="1024">
fn build_request(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&types::RefundSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::RefundSyncType::get_headers(self, req, connectors)?)
.set_body(types::RefundSyncType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexixpay.rs" role="context" start="991" end="993">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexixpay.rs" role="context" start="983" end="989">
fn get_headers(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexixpay.rs" role="context" start="730" end="748">
fn build_request(
&self,
req: &PaymentsCaptureRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsCaptureType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsCaptureType::get_headers(
self, req, connectors,
)?)
.set_body(types::PaymentsCaptureType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexixpay.rs" role="context" start="613" end="626">
fn build_request(
&self,
req: &PaymentsSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&types::PaymentsSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsSyncType::get_headers(self, req, connectors)?)
.build(),
))
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/wellsfargo.rs<|crate|> hyperswitch_connectors<|connector|> wellsfargo anchor=get_url kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/wellsfargo.rs" role="context" start="1220" end="1231">
fn get_url(
&self,
req: &PaymentsIncrementalAuthorizationRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let connector_payment_id = req.request.connector_transaction_id.clone();
Ok(format!(
"{}pts/v2/payments/{}",
self.base_url(connectors),
connector_payment_id
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/wellsfargo.rs" role="context" start="1219" end="1219">
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
fn get_http_method(&self) -> Method {
Method::Patch
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
&self,
req: &PaymentsIncrementalAuthorizationRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let connector_payment_id = req.request.connector_transaction_id.clone();
Ok(format!(
"{}pts/v2/payments/{}",
self.base_url(connectors),
connector_payment_id
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/wellsfargo.rs" role="context" start="1251" end="1271">
fn build_request(
&self,
req: &PaymentsIncrementalAuthorizationRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Patch)
.url(&IncrementalAuthorizationType::get_url(
self, req, connectors,
)?)
.attach_default_headers()
.headers(IncrementalAuthorizationType::get_headers(
self, req, connectors,
)?)
.set_body(IncrementalAuthorizationType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/wellsfargo.rs" role="context" start="1233" end="1250">
fn get_request_body(
&self,
req: &PaymentsIncrementalAuthorizationRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let amount = convert_amount(
self.amount_converter,
MinorUnit::new(req.request.additional_amount),
req.request.currency,
)?;
let connector_router_data = wellsfargo::WellsfargoRouterData::from((amount, req));
let connector_request =
wellsfargo::WellsfargoPaymentsIncrementalAuthorizationRequest::try_from(
&connector_router_data,
)?;
Ok(RequestContent::Json(Box::new(connector_request)))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/wellsfargo.rs" role="context" start="1216" end="1218">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/wellsfargo.rs" role="context" start="1212" end="1214">
fn get_http_method(&self) -> Method {
Method::Patch
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/wellsfargo.rs" role="context" start="1156" end="1169">
fn build_request(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&RefundSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(RefundSyncType::get_headers(self, req, connectors)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/wellsfargo.rs" role="context" start="644" end="660">
fn build_request(
&self,
req: &PaymentsCaptureRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&PaymentsCaptureType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(PaymentsCaptureType::get_headers(self, req, connectors)?)
.set_body(PaymentsCaptureType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/nexixpay.rs<|crate|> hyperswitch_connectors<|connector|> nexixpay anchor=get_request_body kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexixpay.rs" role="context" start="919" end="933">
fn get_request_body(
&self,
req: &RefundsRouterData<Execute>,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let refund_amount = utils::convert_amount(
self.amount_converter,
req.request.minor_refund_amount,
req.request.currency,
)?;
let connector_router_data = nexixpay::NexixpayRouterData::from((refund_amount, req));
let connector_req = nexixpay::NexixpayRefundRequest::try_from(&connector_router_data)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexixpay.rs" role="context" start="918" end="918">
) -> CustomResult<String, errors::ConnectorError> {
let connector_payment_id = get_payment_id((
req.request.connector_metadata.clone(),
Some(nexixpay::NexixpayPaymentIntent::Capture),
))?;
Ok(format!(
"{}/operations/{}/refunds",
self.base_url(connectors),
connector_payment_id
))
}
fn get_request_body(
&self,
req: &RefundsRouterData<Execute>,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let refund_amount = utils::convert_amount(
self.amount_converter,
req.request.minor_refund_amount,
req.request.currency,
)?;
let connector_router_data = nexixpay::NexixpayRouterData::from((refund_amount, req));
let connector_req = nexixpay::NexixpayRefundRequest::try_from(&connector_router_data)?;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexixpay.rs" role="context" start="954" end="971">
fn handle_response(
&self,
data: &RefundsRouterData<Execute>,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundsRouterData<Execute>, errors::ConnectorError> {
let response: nexixpay::RefundResponse = res
.response
.parse_struct("RefundResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexixpay.rs" role="context" start="935" end="952">
fn build_request(
&self,
req: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Post)
.url(&types::RefundExecuteType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::RefundExecuteType::get_headers(
self, req, connectors,
)?)
.set_body(types::RefundExecuteType::get_request_body(
self, req, connectors,
)?)
.build();
Ok(Some(request))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexixpay.rs" role="context" start="903" end="917">
fn get_url(
&self,
req: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let connector_payment_id = get_payment_id((
req.request.connector_metadata.clone(),
Some(nexixpay::NexixpayPaymentIntent::Capture),
))?;
Ok(format!(
"{}/operations/{}/refunds",
self.base_url(connectors),
connector_payment_id
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexixpay.rs" role="context" start="899" end="901">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexixpay.rs" role="context" start="273" end="289">
fn build_request(
&self,
req: &SetupMandateRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::SetupMandateType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::SetupMandateType::get_headers(self, req, connectors)?)
.set_body(types::SetupMandateType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexixpay.rs" role="context" start="838" end="854">
fn build_request(
&self,
req: &PaymentsCancelRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsVoidType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsVoidType::get_headers(self, req, connectors)?)
.set_body(types::PaymentsVoidType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexixpay.rs" role="context" start="67" end="71">
pub fn new() -> &'static Self {
&Self {
amount_converter: &StringMinorUnitForConnector,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexixpay/transformers.rs" role="context" start="43" end="46">
pub struct NexixpayRouterData<T> {
pub amount: StringMinorUnit,
pub router_data: T,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/nomupay.rs<|crate|> hyperswitch_connectors<|connector|> nomupay anchor=new kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nomupay.rs" role="context" start="77" end="82">
pub fn new() -> &'static Self {
&Self {
#[cfg(feature = "payouts")]
amount_converter: &FloatMajorUnitForConnector,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nomupay.rs" role="context" start="76" end="76">
use common_utils::{
request::{Request, RequestBuilder},
types::{AmountConvertor, FloatMajorUnit, FloatMajorUnitForConnector},
};
use hyperswitch_domain_models::{
router_flow_types::payouts::{
PoCancel, PoCreate, PoEligibility, PoFulfill, PoQuote, PoRecipient, PoRecipientAccount,
PoSync,
},
router_request_types::PayoutsData,
router_response_types::PayoutsResponseData,
types::PayoutsRouterData,
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nomupay.rs" role="context" start="94" end="107">
fn box_to_jwt_payload(
body: Box<dyn masking::ErasedMaskSerialize + Send>,
) -> CustomResult<JwtPayload, errors::ConnectorError> {
let str_result = serde_json::to_string(&body)
.change_context(errors::ConnectorError::ProcessingStepFailed(None))?;
let parsed_json: Map<String, Value> = serde_json::from_str(&str_result)
.change_context(errors::ConnectorError::ProcessingStepFailed(None))?;
let jwt_payload = JwtPayload::from_map(parsed_json)
.change_context(errors::ConnectorError::ProcessingStepFailed(None))?;
Ok(jwt_payload)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nomupay.rs" role="context" start="85" end="92">
fn get_private_key(
metadata: &Option<pii::SecretSerdeValue>,
) -> Result<String, errors::ConnectorError> {
match nomupay::NomupayMetadata::try_from(metadata.as_ref()) {
Ok(nomupay_metadata) => Ok(nomupay_metadata.private_key.expose()),
Err(_e) => Err(errors::ConnectorError::NoConnectorMetaData),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nomupay.rs" role="context" start="684" end="702">
fn build_request(
&self,
req: &PayoutsRouterData<PoFulfill>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Post)
.url(&types::PayoutFulfillType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PayoutFulfillType::get_headers(
self, req, connectors,
)?)
.set_body(types::PayoutFulfillType::get_request_body(
self, req, connectors,
)?)
.build();
Ok(Some(request))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nomupay.rs" role="context" start="109" end="162">
fn get_signature(
metadata: &Option<pii::SecretSerdeValue>,
auth: nomupay::NomupayAuthType,
body: RequestContent,
method: &str,
path: String,
) -> CustomResult<String, errors::ConnectorError> {
match body {
RequestContent::Json(masked_json) => {
let expiration_time = SystemTime::now() + Duration::from_secs(4 * 60);
let expires_in = match expiration_time.duration_since(UNIX_EPOCH) {
Ok(duration) => duration.as_secs(),
Err(_e) => 0,
};
let mut option_map = Map::new();
option_map.insert("alg".to_string(), json!(format!("ES256")));
option_map.insert("aud".to_string(), json!(format!("{} {}", method, path)));
option_map.insert("exp".to_string(), json!(expires_in));
option_map.insert("kid".to_string(), json!(auth.kid));
let header = JwsHeader::from_map(option_map)
.change_context(errors::ConnectorError::ProcessingStepFailed(None))?;
let payload = match method {
"GET" => JwtPayload::new(),
_ => box_to_jwt_payload(masked_json)
.change_context(errors::ConnectorError::ProcessingStepFailed(None))?,
};
let private_key = get_private_key(metadata)?;
let signer = ES256
.signer_from_pem(&private_key)
.change_context(errors::ConnectorError::ProcessingStepFailed(None))?;
let nomupay_jwt = jwt::encode_with_signer(&payload, &header, &signer)
.change_context(errors::ConnectorError::ProcessingStepFailed(None))?;
let jws_blocks: Vec<&str> = nomupay_jwt.split('.').collect();
let jws_detached = jws_blocks
.first()
.zip(jws_blocks.get(2))
.map(|(first, third)| format!("{}..{}", first, third))
.ok_or_else(|| errors::ConnectorError::MissingRequiredField {
field_name: "JWS blocks not sufficient for detached payload",
})?;
Ok(jws_detached)
}
_ => Err(errors::ConnectorError::ProcessingStepFailed(None).into()),
}
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei/transformers.rs<|crate|> hyperswitch_connectors<|connector|> nuvei anchor=from kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei/transformers.rs" role="context" start="1891" end="1898">
fn from(item: NuveiWebhookDetails) -> Self {
Self {
transaction_status: Some(NuveiTransactionStatus::from(item.status)),
transaction_id: item.transaction_id,
transaction_type: item.transaction_type,
..Default::default()
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei/transformers.rs" role="context" start="1881" end="1887">
fn from(status: NuveiWebhookStatus) -> Self {
match status {
NuveiWebhookStatus::Approved => Self::Approved,
NuveiWebhookStatus::Declined => Self::Declined,
_ => Self::Processing,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei/transformers.rs" role="context" start="1807" end="1827">
fn get_error_response<T>(
error_code: Option<i64>,
error_msg: &Option<String>,
http_code: u16,
) -> Result<T, Box<ErrorResponse>> {
Err(Box::new(ErrorResponse {
code: error_code
.map(|c| c.to_string())
.unwrap_or_else(|| NO_ERROR_CODE.to_string()),
message: error_msg
.clone()
.unwrap_or_else(|| NO_ERROR_MESSAGE.to_string()),
reason: None,
status_code: http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
}))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei/transformers.rs" role="context" start="543" end="565">
fn try_from(
item: &types::PaymentsAuthorizeSessionTokenRouterData,
) -> Result<Self, Self::Error> {
let connector_meta: NuveiAuthType = NuveiAuthType::try_from(&item.connector_auth_type)?;
let merchant_id = connector_meta.merchant_id;
let merchant_site_id = connector_meta.merchant_site_id;
let client_request_id = item.connector_request_reference_id.clone();
let time_stamp = date_time::DateTime::<date_time::YYYYMMDDHHmmss>::from(date_time::now());
let merchant_secret = connector_meta.merchant_secret;
Ok(Self {
merchant_id: merchant_id.clone(),
merchant_site_id: merchant_site_id.clone(),
client_request_id: client_request_id.clone(),
time_stamp: time_stamp.clone(),
checksum: Secret::new(encode_payload(&[
merchant_id.peek(),
merchant_site_id.peek(),
&client_request_id,
&time_stamp.to_string(),
merchant_secret.peek(),
])?),
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei/transformers.rs" role="context" start="911" end="1060">
fn try_from(
data: (&RouterData<F, Req, PaymentsResponseData>, String),
) -> Result<Self, Self::Error> {
let item = data.0;
let request_data = match item.request.get_payment_method_data_required()?.clone() {
PaymentMethodData::Card(card) => get_card_info(item, &card),
PaymentMethodData::MandatePayment => Self::try_from(item),
PaymentMethodData::Wallet(wallet) => match wallet {
WalletData::GooglePay(gpay_data) => Self::try_from(gpay_data),
WalletData::ApplePay(apple_pay_data) => Ok(Self::from(apple_pay_data)),
WalletData::PaypalRedirect(_) => Self::foreign_try_from((
AlternativePaymentMethodType::Expresscheckout,
None,
item,
)),
WalletData::AliPayQr(_)
| WalletData::AliPayRedirect(_)
| WalletData::AliPayHkRedirect(_)
| WalletData::AmazonPayRedirect(_)
| WalletData::MomoRedirect(_)
| WalletData::KakaoPayRedirect(_)
| WalletData::GoPayRedirect(_)
| WalletData::GcashRedirect(_)
| WalletData::ApplePayRedirect(_)
| WalletData::ApplePayThirdPartySdk(_)
| WalletData::DanaRedirect {}
| WalletData::GooglePayRedirect(_)
| WalletData::GooglePayThirdPartySdk(_)
| WalletData::MbWayRedirect(_)
| WalletData::MobilePayRedirect(_)
| WalletData::PaypalSdk(_)
| WalletData::Paze(_)
| WalletData::SamsungPay(_)
| WalletData::TwintRedirect {}
| WalletData::VippsRedirect {}
| WalletData::TouchNGoRedirect(_)
| WalletData::WeChatPayRedirect(_)
| WalletData::CashappQr(_)
| WalletData::SwishQr(_)
| WalletData::WeChatPayQr(_)
| WalletData::Mifinity(_) => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("nuvei"),
)
.into()),
},
PaymentMethodData::BankRedirect(redirect) => match redirect {
BankRedirectData::Eps { .. } => Self::foreign_try_from((
AlternativePaymentMethodType::Eps,
Some(redirect),
item,
)),
BankRedirectData::Giropay { .. } => Self::foreign_try_from((
AlternativePaymentMethodType::Giropay,
Some(redirect),
item,
)),
BankRedirectData::Ideal { .. } => Self::foreign_try_from((
AlternativePaymentMethodType::Ideal,
Some(redirect),
item,
)),
BankRedirectData::Sofort { .. } => Self::foreign_try_from((
AlternativePaymentMethodType::Sofort,
Some(redirect),
item,
)),
BankRedirectData::BancontactCard { .. }
| BankRedirectData::Bizum {}
| BankRedirectData::Blik { .. }
| BankRedirectData::Eft { .. }
| BankRedirectData::Interac { .. }
| BankRedirectData::OnlineBankingCzechRepublic { .. }
| BankRedirectData::OnlineBankingFinland { .. }
| BankRedirectData::OnlineBankingPoland { .. }
| BankRedirectData::OnlineBankingSlovakia { .. }
| BankRedirectData::Przelewy24 { .. }
| BankRedirectData::Trustly { .. }
| BankRedirectData::OnlineBankingFpx { .. }
| BankRedirectData::OnlineBankingThailand { .. }
| BankRedirectData::OpenBankingUk { .. }
| BankRedirectData::LocalBankRedirect {} => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("nuvei"),
)
.into())
}
},
PaymentMethodData::PayLater(pay_later_data) => match pay_later_data {
PayLaterData::KlarnaRedirect { .. } => {
get_pay_later_info(AlternativePaymentMethodType::Klarna, item)
}
PayLaterData::AfterpayClearpayRedirect { .. } => {
get_pay_later_info(AlternativePaymentMethodType::AfterPay, item)
}
PayLaterData::KlarnaSdk { .. }
| PayLaterData::AffirmRedirect {}
| PayLaterData::PayBrightRedirect {}
| PayLaterData::WalleyRedirect {}
| PayLaterData::AlmaRedirect {}
| PayLaterData::AtomeRedirect {} => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("nuvei"),
)
.into()),
},
PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::CardRedirect(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("nuvei"),
)
.into())
}
}?;
let currency = item.request.get_currency_required()?;
let request = Self::try_from(NuveiPaymentRequestData {
amount: utils::to_currency_base_unit(item.request.get_amount_required()?, currency)?,
currency,
connector_auth_type: item.connector_auth_type.clone(),
client_request_id: item.connector_request_reference_id.clone(),
session_token: Secret::new(data.1),
capture_method: item.request.get_capture_method(),
..Default::default()
})?;
let return_url = item.request.get_return_url_required()?;
Ok(Self {
is_rebilling: request_data.is_rebilling,
user_token_id: request_data.user_token_id,
related_transaction_id: request_data.related_transaction_id,
payment_option: request_data.payment_option,
billing_address: request_data.billing_address,
device_details: request_data.device_details,
url_details: Some(UrlDetails {
success_url: return_url.clone(),
failure_url: return_url.clone(),
pending_url: return_url,
}),
..request
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei/transformers.rs" role="context" start="1830" end="1854">
pub struct NuveiWebhookDetails {
pub ppp_status: Option<String>,
#[serde(rename = "ppp_TransactionID")]
pub ppp_transaction_id: String,
#[serde(rename = "TransactionId")]
pub transaction_id: Option<String>,
pub userid: Option<String>,
pub merchant_unique_id: Option<String>,
#[serde(rename = "customData")]
pub custom_data: Option<String>,
#[serde(rename = "productId")]
pub product_id: String,
pub first_name: Option<String>,
pub last_name: Option<String>,
pub email: Option<String>,
#[serde(rename = "totalAmount")]
pub total_amount: String,
pub currency: String,
#[serde(rename = "responseTimeStamp")]
pub response_time_stamp: String,
#[serde(rename = "Status")]
pub status: NuveiWebhookStatus,
#[serde(rename = "transactionType")]
pub transaction_type: Option<NuveiTransactionType>,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei/transformers.rs" role="context" start="1439" end="1447">
pub enum NuveiTransactionStatus {
Approved,
Declined,
Error,
Redirect,
Pending,
#[default]
Processing,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank/transformers.rs<|crate|> hyperswitch_connectors<|connector|> deutschebank anchor=get_error_response kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank/transformers.rs" role="context" start="511" end="523">
fn get_error_response(error_code: String, error_reason: String, status_code: u16) -> ErrorResponse {
ErrorResponse {
code: error_code.to_string(),
message: error_reason.clone(),
reason: Some(error_reason),
status_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank/transformers.rs" role="context" start="510" end="510">
use hyperswitch_domain_models::{
payment_method_data::{BankDebitData, PaymentMethodData},
router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::{
payments::{Authorize, Capture, CompleteAuthorize, PSync},
refunds::{Execute, RSync},
},
router_request_types::{
CompleteAuthorizeData, PaymentsAuthorizeData, PaymentsCaptureData, PaymentsSyncData,
ResponseId,
},
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsCompleteAuthorizeRouterData, RefundsRouterData,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank/transformers.rs" role="context" start="540" end="616">
fn try_from(
item: ResponseRouterData<
Authorize,
DeutschebankMandatePostResponse,
PaymentsAuthorizeData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
let signed_on = match item.response.approval_date.clone() {
Some(date) => date.chars().take(10).collect(),
None => time::OffsetDateTime::now_utc().date().to_string(),
};
let response_code = item.response.rc.clone();
let is_response_success = is_response_success(&response_code);
match (
item.response.reference.clone(),
item.response.state.clone(),
is_response_success,
) {
(Some(reference), Some(state), true) => Ok(Self {
status: common_enums::AttemptStatus::from(state),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::NoResponseId,
redirection_data: Box::new(Some(RedirectForm::Form {
endpoint: item.data.request.get_complete_authorize_url()?,
method: common_utils::request::Method::Get,
form_fields: HashMap::from([
("reference".to_string(), reference.clone()),
("signed_on".to_string(), signed_on.clone()),
]),
})),
mandate_reference: if item.data.request.is_mandate_payment() {
Box::new(Some(MandateReference {
connector_mandate_id: item.response.mandate_id,
payment_method_id: None,
mandate_metadata: Some(Secret::new(
serde_json::json!(DeutschebankMandateMetadata {
account_holder: item.data.get_billing_address()?.get_full_name()?,
iban: match item.data.request.payment_method_data.clone() {
PaymentMethodData::BankDebit(BankDebitData::SepaBankDebit {
iban,
..
}) => Ok(Secret::from(iban.peek().replace(" ", ""))),
_ => Err(errors::ConnectorError::MissingRequiredField {
field_name:
"payment_method_data.bank_debit.sepa_bank_debit.iban"
}),
}?,
reference: Secret::from(reference.clone()),
signed_on,
}),
)),
connector_mandate_request_reference_id: None,
}))
} else {
Box::new(None)
},
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
}),
_ => Ok(Self {
status: common_enums::AttemptStatus::Failure,
response: Err(get_error_response(
response_code.clone(),
item.response.message.clone(),
item.http_code,
)),
..item.data
}),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank/transformers.rs" role="context" start="525" end="527">
fn is_response_success(rc: &String) -> bool {
rc == "0"
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank/transformers.rs" role="context" start="474" end="488">
fn from(item: DeutschebankSEPAMandateStatus) -> Self {
match item {
DeutschebankSEPAMandateStatus::Active
| DeutschebankSEPAMandateStatus::Created
| DeutschebankSEPAMandateStatus::PendingApproval
| DeutschebankSEPAMandateStatus::PendingSecondaryApproval
| DeutschebankSEPAMandateStatus::PendingReview
| DeutschebankSEPAMandateStatus::PendingSubmission
| DeutschebankSEPAMandateStatus::Submitted => Self::AuthenticationPending,
DeutschebankSEPAMandateStatus::Failed
| DeutschebankSEPAMandateStatus::Discarded
| DeutschebankSEPAMandateStatus::Expired
| DeutschebankSEPAMandateStatus::Replaced => Self::Failure,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank/transformers.rs" role="context" start="362" end="454">
fn try_from(
item: ResponseRouterData<
Authorize,
DeutschebankThreeDSInitializeResponse,
PaymentsAuthorizeData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
match item.response.outcome {
DeutschebankThreeDSInitializeResponseOutcome::Processed => {
match item.response.processed {
Some(processed) => Ok(Self {
status: if is_response_success(&processed.rc) {
match item.data.request.is_auto_capture()? {
true => common_enums::AttemptStatus::Charged,
false => common_enums::AttemptStatus::Authorized,
}
} else {
common_enums::AttemptStatus::AuthenticationFailed
},
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
processed.tx_id.clone(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(processed.tx_id.clone()),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
}),
None => {
let response_string = format!("{:?}", item.response);
Err(
errors::ConnectorError::UnexpectedResponseError(bytes::Bytes::from(
response_string,
))
.into(),
)
}
}
}
DeutschebankThreeDSInitializeResponseOutcome::ChallengeRequired => {
match item.response.challenge_required {
Some(challenge) => Ok(Self {
status: common_enums::AttemptStatus::AuthenticationPending,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::NoResponseId,
redirection_data: Box::new(Some(
RedirectForm::DeutschebankThreeDSChallengeFlow {
acs_url: challenge.acs_url,
creq: challenge.creq,
},
)),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
}),
None => {
let response_string = format!("{:?}", item.response);
Err(
errors::ConnectorError::UnexpectedResponseError(bytes::Bytes::from(
response_string,
))
.into(),
)
}
}
}
DeutschebankThreeDSInitializeResponseOutcome::MethodRequired => Ok(Self {
status: common_enums::AttemptStatus::Failure,
response: Err(ErrorResponse {
code: consts::NO_ERROR_CODE.to_owned(),
message: "METHOD_REQUIRED Flow not supported for deutschebank 3ds payments".to_owned(),
reason: Some("METHOD_REQUIRED Flow is not currently supported for deutschebank 3ds payments".to_owned()),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,network_advice_code: None,
network_decline_code: None,
network_error_message: None,
}),
..item.data
}),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank/transformers.rs" role="context" start="880" end="918">
fn try_from(
item: ResponseRouterData<
CompleteAuthorize,
DeutschebankPaymentsResponse,
CompleteAuthorizeData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
let response_code = item.response.rc.clone();
if is_response_success(&response_code) {
Ok(Self {
status: match item.data.request.is_auto_capture()? {
true => common_enums::AttemptStatus::Charged,
false => common_enums::AttemptStatus::Authorized,
},
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(item.response.tx_id),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
} else {
Ok(Self {
status: common_enums::AttemptStatus::Failure,
response: Err(get_error_response(
response_code.clone(),
item.response.message.clone(),
item.http_code,
)),
..item.data
})
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree/transformers.rs" role="context" start="1264" end="1266">
pub struct ErrorResponse {
errors: Vec<ErrorDetails>,
}
<file_sep path="hyperswitch/crates/api_models/src/errors/types.rs" role="context" start="42" end="52">
struct ErrorResponse<'a> {
#[serde(rename = "type")]
error_type: &'static str,
message: Cow<'a, str>,
code: String,
#[serde(flatten)]
extra: &'a Option<Extra>,
#[cfg(feature = "detailed_errors")]
#[serde(skip_serializing_if = "Option::is_none")]
stacktrace: Option<&'a serde_json::Value>,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/placetopay/transformers.rs<|crate|> hyperswitch_connectors<|connector|> placetopay anchor=try_from kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/placetopay/transformers.rs" role="context" start="518" end="531">
fn try_from(item: &types::PaymentsCancelRouterData) -> Result<Self, Self::Error> {
let auth = PlacetopayAuth::try_from(&item.connector_auth_type)?;
let internal_reference = item
.request
.connector_transaction_id
.parse::<u64>()
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
let action = PlacetopayNextAction::Void;
Ok(Self {
auth,
internal_reference,
action,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/placetopay/transformers.rs" role="context" start="517" end="517">
use common_utils::{consts::BASE64_ENGINE, date_time, types::MinorUnit};
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, generate_random_bytes, BrowserInformationData, CardData as _,
PaymentsAuthorizeRequestData, PaymentsSyncRequestData, RouterData as _,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/placetopay/transformers.rs" role="context" start="499" end="512">
fn try_from(item: &types::PaymentsCaptureRouterData) -> Result<Self, Self::Error> {
let auth = PlacetopayAuth::try_from(&item.connector_auth_type)?;
let internal_reference = item
.request
.connector_transaction_id
.parse::<u64>()
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
let action = PlacetopayNextAction::Checkout;
Ok(Self {
auth,
internal_reference,
action,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/placetopay/transformers.rs" role="context" start="464" end="475">
fn try_from(item: &types::PaymentsSyncRouterData) -> Result<Self, Self::Error> {
let auth = PlacetopayAuth::try_from(&item.connector_auth_type)?;
let internal_reference = item
.request
.get_connector_transaction_id()?
.parse::<u64>()
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
Ok(Self {
auth,
internal_reference,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/placetopay/transformers.rs" role="context" start="167" end="185">
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
let placetopay_auth = PlacetopayAuthType::try_from(auth_type)?;
let nonce_bytes = generate_random_bytes(16);
let now = date_time::date_as_yyyymmddthhmmssmmmz()
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
let seed = format!("{}+00:00", now.split_at(now.len() - 5).0);
let mut context = digest::Context::new(&digest::SHA256);
context.update(&nonce_bytes);
context.update(seed.as_bytes());
context.update(placetopay_auth.tran_key.peek().as_bytes());
let encoded_digest = base64::Engine::encode(&BASE64_ENGINE, context.finish());
let nonce = Secret::new(base64::Engine::encode(&BASE64_ENGINE, &nonce_bytes));
Ok(Self {
login: placetopay_auth.login,
tran_key: encoded_digest.into(),
nonce,
seed,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/placetopay/transformers.rs" role="context" start="403" end="414">
fn try_from(item: &types::RefundsRouterData<RSync>) -> Result<Self, Self::Error> {
let auth = PlacetopayAuth::try_from(&item.connector_auth_type)?;
let internal_reference = item
.request
.connector_transaction_id
.parse::<u64>()
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
Ok(Self {
auth,
internal_reference,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/placetopay/transformers.rs" role="context" start="103" end="103">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/placetopay/transformers.rs" role="context" start="488" end="494">
pub enum PlacetopayNextAction {
Refund,
Reverse,
Void,
Process,
Checkout,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/placetopay/transformers.rs" role="context" start="64" end="69">
pub struct PlacetopayAuth {
login: Secret<String>,
tran_key: Secret<String>,
nonce: Secret<String>,
seed: String,
}
<file_sep path="hyperswitch/crates/api_models/src/payment_methods.rs" role="context" start="2478" end="2478">
type Error = error_stack::Report<errors::ValidationError>;
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/prophetpay/transformers.rs<|crate|> hyperswitch_connectors<|connector|> prophetpay anchor=try_from kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/prophetpay/transformers.rs" role="context" start="705" end="714">
fn try_from(item: &types::RefundSyncRouterData) -> Result<Self, Self::Error> {
let auth_data = ProphetpayAuthType::try_from(&item.connector_auth_type)?;
Ok(Self {
transaction_id: item.request.connector_transaction_id.clone(),
ref_info: item.connector_request_reference_id.to_owned(),
inquiry_reference: item.connector_request_reference_id.clone(),
profile: auth_data.profile_id,
action_type: ProphetpayActionType::get_action_type(&ProphetpayActionType::Inquiry),
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/prophetpay/transformers.rs" role="context" start="704" end="704">
use hyperswitch_domain_models::{
payment_method_data::{CardRedirectData, PaymentMethodData},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::refunds::Execute,
router_request_types::{
CompleteAuthorizeData, CompleteAuthorizeRedirectResponse, PaymentsAuthorizeData, ResponseId,
},
router_response_types::{PaymentsResponseData, RedirectForm, RefundsResponseData},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{self, to_connector_meta},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/prophetpay/transformers.rs" role="context" start="662" end="691">
fn try_from(
item: RefundsResponseRouterData<T, ProphetpayRefundSyncResponse>,
) -> Result<Self, Self::Error> {
if item.response.success {
Ok(Self {
response: Ok(RefundsResponseData {
// no refund id is generated, rather transaction id is used for referring to status in refund also
connector_refund_id: item.data.request.connector_transaction_id.clone(),
refund_status: enums::RefundStatus::Success,
}),
..item.data
})
} else {
Ok(Self {
status: enums::AttemptStatus::Failure,
response: Err(ErrorResponse {
code: NO_ERROR_CODE.to_string(),
message: item.response.response_text.clone(),
reason: Some(item.response.response_text),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
}),
..item.data
})
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/prophetpay/transformers.rs" role="context" start="615" end="648">
fn try_from(
item: RefundsResponseRouterData<Execute, ProphetpayRefundResponse>,
) -> Result<Self, Self::Error> {
if item.response.success {
Ok(Self {
response: Ok(RefundsResponseData {
// no refund id is generated, tranSeqNumber is kept for future usage
connector_refund_id: item.response.tran_seq_number.ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "tran_seq_number",
},
)?,
refund_status: enums::RefundStatus::Success,
}),
..item.data
})
} else {
Ok(Self {
status: enums::AttemptStatus::Failure,
response: Err(ErrorResponse {
code: NO_ERROR_CODE.to_string(),
message: item.response.response_text.clone(),
reason: Some(item.response.response_text),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
}),
..item.data
})
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/prophetpay/transformers.rs" role="context" start="579" end="600">
fn try_from(
item: &ProphetpayRouterData<&types::RefundsRouterData<F>>,
) -> Result<Self, Self::Error> {
if item.router_data.request.payment_amount == item.router_data.request.refund_amount {
let auth_data = ProphetpayAuthType::try_from(&item.router_data.connector_auth_type)?;
let transaction_id = item.router_data.request.connector_transaction_id.to_owned();
let card_token_data: ProphetpayCardTokenData =
to_connector_meta(item.router_data.request.connector_metadata.clone())?;
Ok(Self {
transaction_id,
amount: item.amount.to_owned(),
card_token: card_token_data.card_token,
profile: auth_data.profile_id,
ref_info: item.router_data.request.refund_id.to_owned(),
inquiry_reference: item.router_data.request.refund_id.clone(),
action_type: ProphetpayActionType::get_action_type(&ProphetpayActionType::Refund),
})
} else {
Err(errors::ConnectorError::NotImplemented("Partial Refund".to_string()).into())
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/prophetpay/transformers.rs" role="context" start="347" end="361">
fn try_from(item: &types::PaymentsSyncRouterData) -> Result<Self, Self::Error> {
let auth_data = ProphetpayAuthType::try_from(&item.connector_auth_type)?;
let transaction_id = item
.request
.connector_transaction_id
.get_connector_transaction_id()
.change_context(errors::ConnectorError::MissingConnectorTransactionID)?;
Ok(Self {
transaction_id,
ref_info: item.connector_request_reference_id.to_owned(),
inquiry_reference: item.connector_request_reference_id.clone(),
profile: auth_data.profile_id,
action_type: ProphetpayActionType::get_action_type(&ProphetpayActionType::Inquiry),
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/prophetpay/transformers.rs" role="context" start="336" end="342">
fn get_action_type(&self) -> i8 {
match self {
Self::Charge => 1,
Self::Refund => 3,
Self::Inquiry => 7,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/prophetpay/transformers.rs" role="context" start="36" end="36">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/prophetpay/transformers.rs" role="context" start="329" end="333">
pub enum ProphetpayActionType {
Charge,
Refund,
Inquiry,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/prophetpay/transformers.rs" role="context" start="48" end="52">
pub struct ProphetpayAuthType {
pub(super) user_name: Secret<String>,
pub(super) password: Secret<String>,
pub(super) profile_id: Secret<String>,
}
<file_sep path="hyperswitch/crates/api_models/src/payment_methods.rs" role="context" start="2478" end="2478">
type Error = error_stack::Report<errors::ValidationError>;
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/tsys/transformers.rs<|crate|> hyperswitch_connectors<|connector|> tsys anchor=try_from kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/tsys/transformers.rs" role="context" start="583" end="600">
fn try_from(
item: RefundsResponseRouterData<RSync, TsysSyncResponse>,
) -> Result<Self, Self::Error> {
let tsys_search_response = item.response.search_transaction_response;
let response = match tsys_search_response {
SearchResponseTypes::SuccessResponse(search_response) => Ok(RefundsResponseData {
connector_refund_id: search_response.transaction_details.transaction_id.clone(),
refund_status: enums::RefundStatus::from(search_response.transaction_details),
}),
SearchResponseTypes::ErrorResponse(connector_response) => {
Err(get_error_response(connector_response, item.http_code))
}
};
Ok(Self {
response,
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/tsys/transformers.rs" role="context" start="582" end="582">
use common_enums::enums;
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{self, ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{
self, PaymentsCancelRouterData, PaymentsSyncRouterData, RefundSyncRouterData,
RefundsRouterData,
},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{self, CardData as _, PaymentsAuthorizeRequestData, RefundsRequestData as _},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/tsys/transformers.rs" role="context" start="569" end="578">
fn try_from(item: &RefundSyncRouterData) -> Result<Self, Self::Error> {
let connector_auth: TsysAuthType = TsysAuthType::try_from(&item.connector_auth_type)?;
let search_transaction = TsysSearchTransactionRequest {
device_id: connector_auth.device_id,
transaction_key: connector_auth.transaction_key,
transaction_id: item.request.get_connector_refund_id()?,
developer_id: connector_auth.developer_id,
};
Ok(Self { search_transaction })
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/tsys/transformers.rs" role="context" start="547" end="564">
fn try_from(
item: RefundsResponseRouterData<Execute, RefundResponse>,
) -> Result<Self, Self::Error> {
let tsys_return_response = item.response.return_response;
let response = match tsys_return_response {
TsysResponseTypes::SuccessResponse(return_response) => Ok(RefundsResponseData {
connector_refund_id: return_response.transaction_id,
refund_status: enums::RefundStatus::from(return_response.status),
}),
TsysResponseTypes::ErrorResponse(connector_response) => {
Err(get_error_response(connector_response, item.http_code))
}
};
Ok(Self {
response,
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/tsys/transformers.rs" role="context" start="506" end="516">
fn try_from(item_data: &TsysRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
let item = item_data.router_data;
let connector_auth: TsysAuthType = TsysAuthType::try_from(&item.connector_auth_type)?;
let return_request = TsysReturnRequest {
device_id: connector_auth.device_id,
transaction_key: connector_auth.transaction_key,
transaction_amount: item_data.amount.clone(),
transaction_id: item.request.connector_transaction_id.clone(),
};
Ok(Self { return_request })
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/tsys/transformers.rs" role="context" start="230" end="245">
fn get_error_response(
connector_response: TsysErrorResponse,
status_code: u16,
) -> router_data::ErrorResponse {
router_data::ErrorResponse {
code: connector_response.response_code,
message: connector_response.response_message.clone(),
reason: Some(connector_response.response_message),
status_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/tsys/transformers.rs" role="context" start="529" end="536">
fn from(item: TsysTransactionDetails) -> Self {
match item.transaction_status {
TsysTransactionStatus::Approved => Self::Pending,
//Connector calls refunds as Void
TsysTransactionStatus::Void => Self::Success,
TsysTransactionStatus::Declined => Self::Failure,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/tsys/transformers.rs" role="context" start="64" end="64">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/tsys/transformers.rs" role="context" start="387" end="389">
pub struct TsysSyncResponse {
search_transaction_response: SearchResponseTypes,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/aci/transformers.rs" role="context" start="642" end="642">
type Err = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/api_models/src/payment_methods.rs" role="context" start="2478" end="2478">
type Error = error_stack::Report<errors::ValidationError>;
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs<|crate|> hyperswitch_connectors<|connector|> adyen anchor=get_recurring_processing_model kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="1766" end="1795">
fn get_recurring_processing_model(
item: &PaymentsAuthorizeRouterData,
) -> Result<RecurringDetails, Error> {
match (item.request.setup_future_usage, item.request.off_session) {
(Some(storage_enums::FutureUsage::OffSession), _) => {
let customer_id = item.get_customer_id()?;
let shopper_reference = format!(
"{}_{}",
item.merchant_id.get_string_repr(),
customer_id.get_string_repr()
);
let store_payment_method = item.request.is_mandate_payment();
Ok((
Some(AdyenRecurringModel::UnscheduledCardOnFile),
Some(store_payment_method),
Some(shopper_reference),
))
}
(_, Some(true)) => Ok((
Some(AdyenRecurringModel::UnscheduledCardOnFile),
None,
Some(format!(
"{}_{}",
item.merchant_id.get_string_repr(),
item.get_customer_id()?.get_string_repr()
)),
)),
_ => Ok((None, None, None)),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="1765" end="1765">
use common_enums::enums as storage_enums;
use common_utils::{
errors::{CustomResult, ParsingError},
ext_traits::Encode,
pii::Email,
request::Method,
types::MinorUnit,
};
use hyperswitch_domain_models::{
network_tokenization::NetworkTokenNumber,
payment_method_data::{
BankDebitData, BankRedirectData, BankTransferData, Card, CardRedirectData, GiftCardData,
NetworkTokenData, PayLaterData, PaymentMethodData, VoucherData, WalletData,
},
router_data::{
ConnectorAuthType, ErrorResponse, PaymentMethodBalance, PaymentMethodToken, RouterData,
},
router_request_types::{PaymentsPreProcessingData, ResponseId, SubmitEvidenceRequestData},
router_response_types::{
AcceptDisputeResponse, DefendDisputeResponse, MandateReference, PaymentsResponseData,
RedirectForm, RefundsResponseData, SubmitEvidenceResponse,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsPreProcessingRouterData, RefundsRouterData,
},
};
type Error = error_stack::Report<errors::ConnectorError>;
type RecurringDetails = (Option<AdyenRecurringModel>, Option<bool>, Option<String>);
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="1820" end="1855">
fn get_additional_data(item: &PaymentsAuthorizeRouterData) -> Option<AdditionalData> {
let (authorisation_type, manual_capture) = match item.request.capture_method {
Some(storage_enums::CaptureMethod::Manual) | Some(enums::CaptureMethod::ManualMultiple) => {
(Some(AuthType::PreAuth), Some("true".to_string()))
}
_ => (None, None),
};
let riskdata = item.request.metadata.clone().and_then(get_risk_data);
let execute_three_d = if matches!(item.auth_type, storage_enums::AuthenticationType::ThreeDs) {
Some("true".to_string())
} else {
None
};
if authorisation_type.is_none()
&& manual_capture.is_none()
&& execute_three_d.is_none()
&& riskdata.is_none()
{
//without this if-condition when the above 3 values are None, additionalData will be serialized to JSON like this -> additionalData: {}
//returning None, ensures that additionalData key will not be present in the serialized JSON
None
} else {
Some(AdditionalData {
authorisation_type,
manual_capture,
execute_three_d,
network_tx_reference: None,
recurring_detail_reference: None,
recurring_shopper_reference: None,
recurring_processing_model: None,
riskdata,
..AdditionalData::default()
})
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="1797" end="1818">
fn get_browser_info(item: &PaymentsAuthorizeRouterData) -> Result<Option<AdyenBrowserInfo>, Error> {
if item.auth_type == storage_enums::AuthenticationType::ThreeDs
|| item.payment_method == storage_enums::PaymentMethod::Card
|| item.payment_method == storage_enums::PaymentMethod::BankRedirect
|| item.request.payment_method_type == Some(storage_enums::PaymentMethodType::GoPay)
|| item.request.payment_method_type == Some(storage_enums::PaymentMethodType::GooglePay)
{
let info = item.request.get_browser_info()?;
Ok(Some(AdyenBrowserInfo {
accept_header: info.get_accept_header()?,
language: info.get_language()?,
screen_height: info.get_screen_height()?,
screen_width: info.get_screen_width()?,
color_depth: info.get_color_depth()?,
user_agent: info.get_user_agent()?,
time_zone_offset: info.get_time_zone()?,
java_enabled: info.get_java_enabled()?,
}))
} else {
Ok(None)
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="1757" end="1762">
fn from(item: &PaymentsAuthorizeRouterData) -> Self {
match item.request.off_session {
Some(true) => Self::ContinuedAuthentication,
_ => Self::Ecommerce,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="1726" end="1753">
fn try_from(item: &PaymentsPreProcessingRouterData) -> Result<Self, Self::Error> {
let payment_method = match &item.request.payment_method_data {
Some(PaymentMethodData::GiftCard(gift_card_data)) => match gift_card_data.as_ref() {
GiftCardData::Givex(gift_card_data) => {
let balance_pm = BalancePmData {
number: gift_card_data.number.clone(),
cvc: gift_card_data.cvc.clone(),
};
Ok(AdyenPaymentMethod::PaymentMethodBalance(Box::new(
balance_pm,
)))
}
GiftCardData::PaySafeCard {} => Err(errors::ConnectorError::FlowNotSupported {
flow: "Balance".to_string(),
connector: "adyen".to_string(),
}),
},
_ => Err(errors::ConnectorError::FlowNotSupported {
flow: "Balance".to_string(),
connector: "adyen".to_string(),
}),
}?;
let auth_type = AdyenAuthType::try_from(&item.connector_auth_type)?;
Ok(Self {
payment_method,
merchant_account: auth_type.merchant_account,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="2671" end="2859">
fn try_from(
value: (
&AdyenRouterData<&PaymentsAuthorizeRouterData>,
payments::MandateReferenceId,
),
) -> Result<Self, Self::Error> {
let (item, mandate_ref_id) = value;
let amount = get_amount_data(item);
let auth_type = AdyenAuthType::try_from(&item.router_data.connector_auth_type)?;
let shopper_interaction = AdyenShopperInteraction::from(item.router_data);
let (recurring_processing_model, store_payment_method, shopper_reference) =
get_recurring_processing_model(item.router_data)?;
let browser_info = None;
let additional_data = get_additional_data(item.router_data);
let return_url = item.router_data.request.get_router_return_url()?;
let payment_method_type = item.router_data.request.payment_method_type;
let payment_method = match mandate_ref_id {
payments::MandateReferenceId::ConnectorMandateId(connector_mandate_ids) => {
let adyen_mandate = AdyenMandate {
payment_type: match payment_method_type {
Some(pm_type) => PaymentType::try_from(&pm_type)?,
None => PaymentType::Scheme,
},
stored_payment_method_id: Secret::new(
connector_mandate_ids
.get_connector_mandate_id()
.ok_or_else(missing_field_err("mandate_id"))?,
),
};
Ok::<PaymentMethod<'_>, Self::Error>(PaymentMethod::AdyenMandatePaymentMethod(
Box::new(adyen_mandate),
))
}
payments::MandateReferenceId::NetworkMandateId(network_mandate_id) => {
match item.router_data.request.payment_method_data {
PaymentMethodData::CardDetailsForNetworkTransactionId(
ref card_details_for_network_transaction_id,
) => {
let brand = match card_details_for_network_transaction_id
.card_network
.clone()
.and_then(get_adyen_card_network)
{
Some(card_network) => card_network,
None => CardBrand::try_from(
&card_details_for_network_transaction_id.get_card_issuer()?,
)?,
};
let card_holder_name = item.router_data.get_optional_billing_full_name();
let adyen_card = AdyenCard {
number: card_details_for_network_transaction_id.card_number.clone(),
expiry_month: card_details_for_network_transaction_id
.card_exp_month
.clone(),
expiry_year: card_details_for_network_transaction_id
.get_expiry_year_4_digit()
.clone(),
cvc: None,
holder_name: card_holder_name,
brand: Some(brand),
network_payment_reference: Some(Secret::new(network_mandate_id)),
};
Ok(PaymentMethod::AdyenPaymentMethod(Box::new(
AdyenPaymentMethod::AdyenCard(Box::new(adyen_card)),
)))
}
PaymentMethodData::CardRedirect(_)
| PaymentMethodData::Wallet(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::Card(_) => Err(errors::ConnectorError::NotSupported {
message: "Network tokenization for payment method".to_string(),
connector: "Adyen",
})?,
}
}
payments::MandateReferenceId::NetworkTokenWithNTI(network_mandate_id) => {
match item.router_data.request.payment_method_data {
PaymentMethodData::NetworkToken(ref token_data) => {
let card_issuer = token_data.get_card_issuer()?;
let brand = CardBrand::try_from(&card_issuer)?;
let card_holder_name = item.router_data.get_optional_billing_full_name();
let adyen_network_token = AdyenNetworkTokenData {
number: token_data.get_network_token(),
expiry_month: token_data.get_network_token_expiry_month(),
expiry_year: token_data.get_expiry_year_4_digit(),
holder_name: card_holder_name,
brand: Some(brand), // FIXME: Remove hardcoding
network_payment_reference: Some(Secret::new(
network_mandate_id.network_transaction_id,
)),
};
Ok(PaymentMethod::AdyenPaymentMethod(Box::new(
AdyenPaymentMethod::NetworkToken(Box::new(adyen_network_token)),
)))
}
PaymentMethodData::Card(_)
| PaymentMethodData::CardRedirect(_)
| PaymentMethodData::Wallet(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {
Err(errors::ConnectorError::NotSupported {
message: "Network tokenization for payment method".to_string(),
connector: "Adyen",
})?
}
}
} //
}?;
let (store, splits) = match item.router_data.request.split_payments.as_ref() {
Some(common_types::payments::SplitPaymentsRequest::AdyenSplitPayment(
adyen_split_payment,
)) => get_adyen_split_request(adyen_split_payment, item.router_data.request.currency),
_ => (None, None),
};
let device_fingerprint = item
.router_data
.request
.metadata
.clone()
.and_then(get_device_fingerprint);
let billing_address =
get_address_info(item.router_data.get_optional_billing()).and_then(Result::ok);
let delivery_address =
get_address_info(item.router_data.get_optional_shipping()).and_then(Result::ok);
let telephone_number = item.router_data.get_optional_billing_phone_number();
Ok(AdyenPaymentRequest {
amount,
merchant_account: auth_type.merchant_account,
payment_method,
reference: item.router_data.connector_request_reference_id.clone(),
return_url,
shopper_interaction,
recurring_processing_model,
browser_info,
additional_data,
mpi_data: None,
telephone_number,
shopper_name: None,
shopper_email: None,
shopper_locale: None,
social_security_number: None,
billing_address,
delivery_address,
country_code: None,
line_items: None,
shopper_reference,
store_payment_method,
channel: None,
shopper_statement: item.router_data.request.statement_descriptor.clone(),
shopper_ip: item.router_data.request.get_ip_address_as_optional(),
merchant_order_reference: item.router_data.request.merchant_order_reference_id.clone(),
store,
splits,
device_fingerprint,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="3027" end="3094">
fn try_from(
value: (&AdyenRouterData<&PaymentsAuthorizeRouterData>, &VoucherData),
) -> Result<Self, Self::Error> {
let (item, voucher_data) = value;
let amount = get_amount_data(item);
let auth_type = AdyenAuthType::try_from(&item.router_data.connector_auth_type)?;
let shopper_interaction = AdyenShopperInteraction::from(item.router_data);
let recurring_processing_model = get_recurring_processing_model(item.router_data)?.0;
let browser_info = get_browser_info(item.router_data)?;
let additional_data = get_additional_data(item.router_data);
let payment_method = PaymentMethod::AdyenPaymentMethod(Box::new(
AdyenPaymentMethod::try_from((voucher_data, item.router_data))?,
));
let return_url = item.router_data.request.get_router_return_url()?;
let social_security_number = get_social_security_number(voucher_data);
let billing_address =
get_address_info(item.router_data.get_optional_billing()).and_then(Result::ok);
let shopper_name = get_shopper_name(item.router_data.get_optional_billing());
let (store, splits) = match item.router_data.request.split_payments.as_ref() {
Some(common_types::payments::SplitPaymentsRequest::AdyenSplitPayment(
adyen_split_payment,
)) => get_adyen_split_request(adyen_split_payment, item.router_data.request.currency),
_ => (None, None),
};
let device_fingerprint = item
.router_data
.request
.metadata
.clone()
.and_then(get_device_fingerprint);
let delivery_address =
get_address_info(item.router_data.get_optional_shipping()).and_then(Result::ok);
let telephone_number = item.router_data.get_optional_billing_phone_number();
let request = AdyenPaymentRequest {
amount,
merchant_account: auth_type.merchant_account,
payment_method,
reference: item.router_data.connector_request_reference_id.to_string(),
return_url,
browser_info,
shopper_interaction,
recurring_processing_model,
additional_data,
shopper_name,
shopper_locale: None,
shopper_email: item.router_data.get_optional_billing_email(),
social_security_number,
mpi_data: None,
telephone_number,
billing_address,
delivery_address,
country_code: None,
line_items: None,
shopper_reference: None,
store_payment_method: None,
channel: None,
shopper_statement: item.router_data.request.statement_descriptor.clone(),
shopper_ip: item.router_data.request.get_ip_address_as_optional(),
merchant_order_reference: item.router_data.request.merchant_order_reference_id.clone(),
store,
splits,
device_fingerprint,
};
Ok(request)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="66" end="66">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="1764" end="1764">
type RecurringDetails = (Option<AdyenRecurringModel>, Option<bool>, Option<String>);
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="116" end="119">
pub enum AdyenRecurringModel {
UnscheduledCardOnFile,
CardOnFile,
}
<file_sep path="hyperswitch/crates/api_models/src/payment_methods.rs" role="context" start="2478" end="2478">
type Error = error_stack::Report<errors::ValidationError>;
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/wellsfargo/transformers.rs<|crate|> hyperswitch_connectors<|connector|> wellsfargo anchor=build_bill_to kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/wellsfargo/transformers.rs" role="context" start="837" end="869">
fn build_bill_to(
address_details: Option<&hyperswitch_domain_models::address::Address>,
email: pii::Email,
) -> Result<BillTo, error_stack::Report<errors::ConnectorError>> {
let phone_number = get_phone_number(address_details);
let default_address = BillTo {
first_name: None,
last_name: None,
address1: None,
locality: None,
administrative_area: None,
postal_code: None,
country: None,
email: email.clone(),
phone_number: phone_number.clone(),
};
let ad = Ok(address_details
.and_then(|addr| {
addr.address.as_ref().map(|addr| BillTo {
first_name: addr.first_name.clone(),
last_name: addr.last_name.clone(),
address1: addr.line1.clone(),
locality: addr.city.clone(),
administrative_area: addr.to_state_code_as_optional().ok().flatten(),
postal_code: addr.zip.clone(),
country: addr.country,
email,
phone_number: phone_number.clone(),
})
})
.unwrap_or(default_address));
ad
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/wellsfargo/transformers.rs" role="context" start="836" end="836">
use common_utils::{
consts, pii,
types::{SemanticVersion, StringMajorUnit},
};
use hyperswitch_domain_models::{
payment_method_data::{
ApplePayWalletData, BankDebitData, GooglePayWalletData, PaymentMethodData, WalletData,
},
router_data::{
AdditionalPaymentMethodConnectorResponse, ApplePayPredecryptData, ConnectorAuthType,
ConnectorResponseData, ErrorResponse, PaymentMethodToken, RouterData,
},
router_flow_types::{
payments::Authorize,
refunds::{Execute, RSync},
SetupMandate,
},
router_request_types::{
PaymentsAuthorizeData, PaymentsCancelData, PaymentsCaptureData, PaymentsSyncData,
ResponseId, SetupMandateRequestData,
},
router_response_types::{MandateReference, PaymentsResponseData, RefundsResponseData},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsIncrementalAuthorizationRouterData, RefundsRouterData, SetupMandateRouterData,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/wellsfargo/transformers.rs" role="context" start="893" end="963">
fn try_from(
(item, ccard): (
&WellsfargoRouterData<&PaymentsAuthorizeRouterData>,
hyperswitch_domain_models::payment_method_data::Card,
),
) -> Result<Self, Self::Error> {
let email = item.router_data.request.get_email()?;
let bill_to = build_bill_to(item.router_data.get_optional_billing(), email)?;
let order_information = OrderInformationWithBill::from((item, Some(bill_to)));
let card_issuer = ccard.get_card_issuer();
let card_type = match card_issuer {
Ok(issuer) => Some(String::from(issuer)),
Err(_) => None,
};
let payment_information = PaymentInformation::Cards(Box::new(CardPaymentInformation {
card: Card {
number: ccard.card_number,
expiration_month: ccard.card_exp_month,
expiration_year: ccard.card_exp_year,
security_code: Some(ccard.card_cvc),
card_type: card_type.clone(),
},
}));
let processing_information = ProcessingInformation::try_from((item, None, card_type))?;
let client_reference_information = ClientReferenceInformation::from(item);
let merchant_defined_information = item
.router_data
.request
.metadata
.clone()
.map(convert_metadata_to_merchant_defined_info);
let consumer_authentication_information = item
.router_data
.request
.authentication_data
.as_ref()
.map(|authn_data| {
let (ucaf_authentication_data, cavv) =
if ccard.card_network == Some(common_enums::CardNetwork::Mastercard) {
(Some(Secret::new(authn_data.cavv.clone())), None)
} else {
(None, Some(authn_data.cavv.clone()))
};
WellsfargoConsumerAuthInformation {
ucaf_collection_indicator: None,
cavv,
ucaf_authentication_data,
xid: authn_data.threeds_server_transaction_id.clone(),
directory_server_transaction_id: authn_data
.ds_trans_id
.clone()
.map(Secret::new),
specification_version: None,
pa_specification_version: authn_data.message_version.clone(),
veres_enrolled: Some("Y".to_string()),
}
});
Ok(Self {
processing_information,
payment_information,
order_information,
client_reference_information,
consumer_authentication_information,
merchant_defined_information,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/wellsfargo/transformers.rs" role="context" start="871" end="884">
fn convert_metadata_to_merchant_defined_info(metadata: Value) -> Vec<MerchantDefinedInformation> {
let hashmap: std::collections::BTreeMap<String, Value> =
serde_json::from_str(&metadata.to_string()).unwrap_or(std::collections::BTreeMap::new());
let mut vector = Vec::new();
let mut iter = 1;
for (key, value) in hashmap {
vector.push(MerchantDefinedInformation {
key: iter,
value: format!("{key}={value}"),
});
iter += 1;
}
vector
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/wellsfargo/transformers.rs" role="context" start="822" end="835">
fn get_phone_number(
item: Option<&hyperswitch_domain_models::address::Address>,
) -> Option<Secret<String>> {
item.as_ref()
.and_then(|billing| billing.phone.as_ref())
.and_then(|phone| {
phone.number.as_ref().and_then(|number| {
phone
.country_code
.as_ref()
.map(|cc| Secret::new(format!("{}{}", cc, number.peek())))
})
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/wellsfargo/transformers.rs" role="context" start="806" end="819">
fn from(
(item, bill_to): (
&WellsfargoRouterData<&PaymentsAuthorizeRouterData>,
Option<BillTo>,
),
) -> Self {
Self {
amount_details: Amount {
total_amount: item.amount.to_owned(),
currency: item.router_data.request.currency,
},
bill_to,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/wellsfargo/transformers.rs" role="context" start="1107" end="1150">
fn try_from(
(item, bank_debit_data): (
&WellsfargoRouterData<&PaymentsAuthorizeRouterData>,
BankDebitData,
),
) -> Result<Self, Self::Error> {
let email = item.router_data.request.get_email()?;
let bill_to = build_bill_to(item.router_data.get_optional_billing(), email)?;
let order_information = OrderInformationWithBill::from((item, Some(bill_to)));
let payment_information = match bank_debit_data {
BankDebitData::AchBankDebit {
account_number,
routing_number,
bank_type,
..
} => Ok(PaymentInformation::AchDebitPayment(Box::new(
AchPaymentInformation {
bank: AchBankAccount {
account: Account {
account_type: AccountType::try_from(bank_type)?,
number: account_number,
},
routing_number,
},
},
))),
BankDebitData::SepaBankDebit { .. }
| BankDebitData::BacsBankDebit { .. }
| BankDebitData::BecsBankDebit { .. } => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("Wellsfargo"),
)),
}?;
let processing_information =
ProcessingInformation::try_from((item, Some(PaymentSolution::GooglePay), None))?;
let client_reference_information = ClientReferenceInformation::from(item);
Ok(Self {
processing_information,
payment_information,
order_information,
client_reference_information,
consumer_authentication_information: None,
merchant_defined_information: None,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/wellsfargo/transformers.rs" role="context" start="1044" end="1081">
fn try_from(
(item, google_pay_data): (
&WellsfargoRouterData<&PaymentsAuthorizeRouterData>,
GooglePayWalletData,
),
) -> Result<Self, Self::Error> {
let email = item.router_data.request.get_email()?;
let bill_to = build_bill_to(item.router_data.get_optional_billing(), email)?;
let order_information = OrderInformationWithBill::from((item, Some(bill_to)));
let payment_information =
PaymentInformation::GooglePay(Box::new(GooglePayPaymentInformation {
fluid_data: FluidData {
value: Secret::from(
consts::BASE64_ENGINE.encode(google_pay_data.tokenization_data.token),
),
descriptor: None,
},
}));
let processing_information =
ProcessingInformation::try_from((item, Some(PaymentSolution::GooglePay), None))?;
let client_reference_information = ClientReferenceInformation::from(item);
let merchant_defined_information = item
.router_data
.request
.metadata
.clone()
.map(convert_metadata_to_merchant_defined_info);
Ok(Self {
processing_information,
payment_information,
order_information,
client_reference_information,
consumer_authentication_information: None,
merchant_defined_information,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/wellsfargo/transformers.rs" role="context" start="529" end="541">
pub struct BillTo {
first_name: Option<Secret<String>>,
last_name: Option<Secret<String>>,
address1: Option<Secret<String>>,
locality: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
administrative_area: Option<Secret<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
postal_code: Option<Secret<String>>,
country: Option<enums::CountryAlpha2>,
email: pii::Email,
phone_number: Option<Secret<String>>,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globalpay/requests.rs" role="context" start="301" end="318">
pub struct Address {
/// Merchant defined field common to all transactions that are part of the same order.
pub city: Option<Secret<String>>,
/// The country in ISO-3166-1(alpha-2 code) format.
pub country: Option<String>,
/// First line of the address.
pub line_1: Option<Secret<String>>,
/// Second line of the address.
pub line_2: Option<Secret<String>>,
/// Third line of the address.
pub line_3: Option<Secret<String>>,
/// The city or town of the address.
pub postal_code: Option<Secret<String>>,
/// The state or region of the address. ISO 3166-2 minus the country code itself. For
/// example, US Illinois = IL, or in the case of GB counties Wiltshire = WI or Aberdeenshire
/// = ABD
pub state: Option<String>,
}
<file_sep path="hyperswitch/migrations/2025-02-06-111828_drop_int_id_column_accross_database/up.sql" role="context" start="20" end="36">
------------------------ Payment Attempt -----------------------
ALTER TABLE payment_attempt DROP COLUMN id;
------------------------ Payment Methods -----------------------
ALTER TABLE payment_methods DROP COLUMN IF EXISTS id;
------------------------ Address -----------------------
ALTER TABLE address DROP COLUMN IF EXISTS id;
------------------------ Dispute -----------------------
ALTER TABLE dispute DROP COLUMN IF EXISTS id;
------------------------ Mandate -----------------------
ALTER TABLE mandate DROP COLUMN IF EXISTS id;
------------------------ Refund -----------------------
<file_sep path="hyperswitch/crates/api_models/src/payments.rs" role="context" start="4244" end="4252">
pub struct Address {
/// Provide the address details
pub address: Option<AddressDetails>,
pub phone: Option<PhoneDetails>,
#[schema(value_type = Option<String>)]
pub email: Option<Email>,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs<|crate|> hyperswitch_connectors<|connector|> adyen anchor=get_additional_data kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="1820" end="1855">
fn get_additional_data(item: &PaymentsAuthorizeRouterData) -> Option<AdditionalData> {
let (authorisation_type, manual_capture) = match item.request.capture_method {
Some(storage_enums::CaptureMethod::Manual) | Some(enums::CaptureMethod::ManualMultiple) => {
(Some(AuthType::PreAuth), Some("true".to_string()))
}
_ => (None, None),
};
let riskdata = item.request.metadata.clone().and_then(get_risk_data);
let execute_three_d = if matches!(item.auth_type, storage_enums::AuthenticationType::ThreeDs) {
Some("true".to_string())
} else {
None
};
if authorisation_type.is_none()
&& manual_capture.is_none()
&& execute_three_d.is_none()
&& riskdata.is_none()
{
//without this if-condition when the above 3 values are None, additionalData will be serialized to JSON like this -> additionalData: {}
//returning None, ensures that additionalData key will not be present in the serialized JSON
None
} else {
Some(AdditionalData {
authorisation_type,
manual_capture,
execute_three_d,
network_tx_reference: None,
recurring_detail_reference: None,
recurring_shopper_reference: None,
recurring_processing_model: None,
riskdata,
..AdditionalData::default()
})
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="1819" end="1819">
use api_models::{
enums,
payments::{self, QrCodeInformation, VoucherNextStepData},
};
use common_enums::enums as storage_enums;
use common_utils::{
errors::{CustomResult, ParsingError},
ext_traits::Encode,
pii::Email,
request::Method,
types::MinorUnit,
};
use hyperswitch_domain_models::{
network_tokenization::NetworkTokenNumber,
payment_method_data::{
BankDebitData, BankRedirectData, BankTransferData, Card, CardRedirectData, GiftCardData,
NetworkTokenData, PayLaterData, PaymentMethodData, VoucherData, WalletData,
},
router_data::{
ConnectorAuthType, ErrorResponse, PaymentMethodBalance, PaymentMethodToken, RouterData,
},
router_request_types::{PaymentsPreProcessingData, ResponseId, SubmitEvidenceRequestData},
router_response_types::{
AcceptDisputeResponse, DefendDisputeResponse, MandateReference, PaymentsResponseData,
RedirectForm, RefundsResponseData, SubmitEvidenceResponse,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsPreProcessingRouterData, RefundsRouterData,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="1866" end="1871">
fn get_amount_data(item: &AdyenRouterData<&PaymentsAuthorizeRouterData>) -> Amount {
Amount {
currency: item.router_data.request.currency,
value: item.amount.to_owned(),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="1857" end="1864">
fn get_channel_type(pm_type: Option<storage_enums::PaymentMethodType>) -> Option<Channel> {
pm_type.as_ref().and_then(|pmt| match pmt {
storage_enums::PaymentMethodType::GoPay | storage_enums::PaymentMethodType::Vipps => {
Some(Channel::Web)
}
_ => None,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="1797" end="1818">
fn get_browser_info(item: &PaymentsAuthorizeRouterData) -> Result<Option<AdyenBrowserInfo>, Error> {
if item.auth_type == storage_enums::AuthenticationType::ThreeDs
|| item.payment_method == storage_enums::PaymentMethod::Card
|| item.payment_method == storage_enums::PaymentMethod::BankRedirect
|| item.request.payment_method_type == Some(storage_enums::PaymentMethodType::GoPay)
|| item.request.payment_method_type == Some(storage_enums::PaymentMethodType::GooglePay)
{
let info = item.request.get_browser_info()?;
Ok(Some(AdyenBrowserInfo {
accept_header: info.get_accept_header()?,
language: info.get_language()?,
screen_height: info.get_screen_height()?,
screen_width: info.get_screen_width()?,
color_depth: info.get_color_depth()?,
user_agent: info.get_user_agent()?,
time_zone_offset: info.get_time_zone()?,
java_enabled: info.get_java_enabled()?,
}))
} else {
Ok(None)
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="1766" end="1795">
fn get_recurring_processing_model(
item: &PaymentsAuthorizeRouterData,
) -> Result<RecurringDetails, Error> {
match (item.request.setup_future_usage, item.request.off_session) {
(Some(storage_enums::FutureUsage::OffSession), _) => {
let customer_id = item.get_customer_id()?;
let shopper_reference = format!(
"{}_{}",
item.merchant_id.get_string_repr(),
customer_id.get_string_repr()
);
let store_payment_method = item.request.is_mandate_payment();
Ok((
Some(AdyenRecurringModel::UnscheduledCardOnFile),
Some(store_payment_method),
Some(shopper_reference),
))
}
(_, Some(true)) => Ok((
Some(AdyenRecurringModel::UnscheduledCardOnFile),
None,
Some(format!(
"{}_{}",
item.merchant_id.get_string_repr(),
item.get_customer_id()?.get_string_repr()
)),
)),
_ => Ok((None, None, None)),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="3365" end="3447">
fn try_from(
value: (&AdyenRouterData<&PaymentsAuthorizeRouterData>, &WalletData),
) -> Result<Self, Self::Error> {
let (item, wallet_data) = value;
let amount = get_amount_data(item);
let auth_type = AdyenAuthType::try_from(&item.router_data.connector_auth_type)?;
let browser_info = get_browser_info(item.router_data)?;
let additional_data = get_additional_data(item.router_data);
let payment_method = PaymentMethod::AdyenPaymentMethod(Box::new(
AdyenPaymentMethod::try_from((wallet_data, item.router_data))?,
));
let shopper_interaction = AdyenShopperInteraction::from(item.router_data);
let channel = get_channel_type(item.router_data.request.payment_method_type);
let (recurring_processing_model, store_payment_method, shopper_reference) =
get_recurring_processing_model(item.router_data)?;
let return_url = item.router_data.request.get_router_return_url()?;
let shopper_email = get_shopper_email(item.router_data, store_payment_method.is_some())?;
let billing_address =
get_address_info(item.router_data.get_optional_billing()).and_then(Result::ok);
let mpi_data = if let WalletData::Paze(_) = wallet_data {
match item.router_data.payment_method_token.clone() {
Some(PaymentMethodToken::PazeDecrypt(paze_decrypted_data)) => Some(AdyenMpiData {
directory_response: "Y".to_string(),
authentication_response: "Y".to_string(),
token_authentication_verification_value: paze_decrypted_data
.token
.payment_account_reference,
eci: paze_decrypted_data.eci,
}),
_ => None,
}
} else {
None
};
let (store, splits) = match item.router_data.request.split_payments.as_ref() {
Some(common_types::payments::SplitPaymentsRequest::AdyenSplitPayment(
adyen_split_payment,
)) => get_adyen_split_request(adyen_split_payment, item.router_data.request.currency),
_ => (None, None),
};
let device_fingerprint = item
.router_data
.request
.metadata
.clone()
.and_then(get_device_fingerprint);
let delivery_address =
get_address_info(item.router_data.get_optional_shipping()).and_then(Result::ok);
let telephone_number = item.router_data.get_optional_billing_phone_number();
Ok(AdyenPaymentRequest {
amount,
merchant_account: auth_type.merchant_account,
payment_method,
reference: item.router_data.connector_request_reference_id.clone(),
return_url,
shopper_interaction,
recurring_processing_model,
browser_info,
additional_data,
mpi_data,
telephone_number,
shopper_name: None,
shopper_email,
shopper_locale: None,
social_security_number: None,
billing_address,
delivery_address,
country_code: None,
line_items: None,
shopper_reference,
store_payment_method,
channel,
shopper_statement: item.router_data.request.statement_descriptor.clone(),
shopper_ip: item.router_data.request.get_ip_address_as_optional(),
merchant_order_reference: item.router_data.request.merchant_order_reference_id.clone(),
store,
splits,
device_fingerprint,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="3457" end="3539">
fn try_from(
value: (
&AdyenRouterData<&PaymentsAuthorizeRouterData>,
&PayLaterData,
),
) -> Result<Self, Self::Error> {
let (item, paylater_data) = value;
let amount = get_amount_data(item);
let auth_type = AdyenAuthType::try_from(&item.router_data.connector_auth_type)?;
let browser_info = get_browser_info(item.router_data)?;
let additional_data = get_additional_data(item.router_data);
let country_code = get_country_code(item.router_data.get_optional_billing());
let shopper_interaction = AdyenShopperInteraction::from(item.router_data);
let shopper_reference = build_shopper_reference(
&item.router_data.customer_id,
item.router_data.merchant_id.clone(),
);
let (recurring_processing_model, store_payment_method, _) =
get_recurring_processing_model(item.router_data)?;
let return_url = item.router_data.request.get_router_return_url()?;
let shopper_name = get_shopper_name(item.router_data.get_optional_billing());
let shopper_email = item.router_data.get_optional_billing_email();
let billing_address =
get_address_info(item.router_data.get_optional_billing()).and_then(Result::ok);
let delivery_address =
get_address_info(item.router_data.get_optional_shipping()).and_then(Result::ok);
let line_items = Some(get_line_items(item));
let telephone_number = get_telephone_number(item.router_data);
let payment_method =
PaymentMethod::AdyenPaymentMethod(Box::new(AdyenPaymentMethod::try_from((
paylater_data,
&country_code,
&shopper_email,
&shopper_reference,
&shopper_name,
&telephone_number,
&billing_address,
&delivery_address,
))?));
let (store, splits) = match item.router_data.request.split_payments.as_ref() {
Some(common_types::payments::SplitPaymentsRequest::AdyenSplitPayment(
adyen_split_payment,
)) => get_adyen_split_request(adyen_split_payment, item.router_data.request.currency),
_ => (None, None),
};
let device_fingerprint = item
.router_data
.request
.metadata
.clone()
.and_then(get_device_fingerprint);
Ok(AdyenPaymentRequest {
amount,
merchant_account: auth_type.merchant_account,
payment_method,
reference: item.router_data.connector_request_reference_id.clone(),
return_url,
shopper_interaction,
recurring_processing_model,
browser_info,
additional_data,
telephone_number,
shopper_name,
shopper_email,
mpi_data: None,
shopper_locale: None,
social_security_number: None,
billing_address,
delivery_address,
country_code,
line_items,
shopper_reference,
store_payment_method,
channel: None,
shopper_statement: item.router_data.request.statement_descriptor.clone(),
shopper_ip: item.router_data.request.get_ip_address_as_optional(),
merchant_order_reference: item.router_data.request.merchant_order_reference_id.clone(),
store,
splits,
device_fingerprint,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="129" end="148">
pub struct AdditionalData {
authorisation_type: Option<AuthType>,
manual_capture: Option<String>,
execute_three_d: Option<String>,
pub recurring_processing_model: Option<AdyenRecurringModel>,
/// Enable recurring details in dashboard to receive this ID, https://docs.adyen.com/online-payments/tokenization/create-and-use-tokens#test-and-go-live
#[serde(rename = "recurring.recurringDetailReference")]
recurring_detail_reference: Option<Secret<String>>,
#[serde(rename = "recurring.shopperReference")]
recurring_shopper_reference: Option<String>,
network_tx_reference: Option<Secret<String>>,
#[cfg(feature = "payouts")]
payout_eligible: Option<PayoutEligibility>,
funds_availability: Option<String>,
refusal_reason_raw: Option<String>,
refusal_code_raw: Option<String>,
merchant_advice_code: Option<String>,
#[serde(flatten)]
riskdata: Option<RiskData>,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="122" end="125">
pub enum AuthType {
#[default]
PreAuth,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/multisafepay/transformers.rs" role="context" start="909" end="922">
pub struct Data {
#[serde(rename = "type")]
pub payment_type: Option<String>,
pub order_id: String,
pub currency: Option<String>,
pub amount: Option<MinorUnit>,
pub description: Option<String>,
pub capture: Option<String>,
pub payment_url: Option<Url>,
pub status: Option<MultisafepayPaymentStatus>,
pub reason: Option<String>,
pub reason_code: Option<String>,
pub payment_details: Option<MultisafepayPaymentDetails>,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs<|crate|> hyperswitch_connectors<|connector|> authorizedotnet anchor=foreign_try_from kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs" role="context" start="1205" end="1298">
fn foreign_try_from(
(item, is_auto_capture): (
ResponseRouterData<F, AuthorizedotnetPaymentsResponse, T, PaymentsResponseData>,
bool,
),
) -> Result<Self, Self::Error> {
match &item.response.transaction_response {
Some(TransactionResponse::AuthorizedotnetTransactionResponse(transaction_response)) => {
let status = get_payment_status((
transaction_response.response_code.clone(),
is_auto_capture,
));
let error = transaction_response.errors.as_ref().and_then(|errors| {
errors.iter().next().map(|error| ErrorResponse {
code: error.error_code.clone(),
message: error.error_text.clone(),
reason: Some(error.error_text.clone()),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(transaction_response.transaction_id.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
});
let metadata = transaction_response
.account_number
.as_ref()
.map(|acc_no| {
construct_refund_payment_details(acc_no.clone().expose()).encode_to_value()
})
.transpose()
.change_context(errors::ConnectorError::MissingRequiredField {
field_name: "connector_metadata",
})?;
let url = transaction_response
.secure_acceptance
.as_ref()
.and_then(|x| x.secure_acceptance_url.to_owned());
let redirection_data = url.map(|url| RedirectForm::from((url, Method::Get)));
let mandate_reference = item.response.profile_response.map(|profile_response| {
let payment_profile_id = profile_response
.customer_payment_profile_id_list
.and_then(|customer_payment_profile_id_list| {
customer_payment_profile_id_list.first().cloned()
});
MandateReference {
connector_mandate_id: profile_response.customer_profile_id.and_then(
|customer_profile_id| {
payment_profile_id.map(|payment_profile_id| {
format!("{customer_profile_id}-{payment_profile_id}")
})
},
),
payment_method_id: None,
mandate_metadata: None,
connector_mandate_request_reference_id: None,
}
});
Ok(Self {
status,
response: match error {
Some(err) => Err(err),
None => Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
transaction_response.transaction_id.clone(),
),
redirection_data: Box::new(redirection_data),
mandate_reference: Box::new(mandate_reference),
connector_metadata: metadata,
network_txn_id: transaction_response
.network_trans_id
.clone()
.map(|network_trans_id| network_trans_id.expose()),
connector_response_reference_id: Some(
transaction_response.transaction_id.clone(),
),
incremental_authorization_allowed: None,
charges: None,
}),
},
..item.data
})
}
Some(TransactionResponse::AuthorizedotnetTransactionResponseError(_)) | None => {
Ok(Self {
status: enums::AttemptStatus::Failure,
response: Err(get_err_response(item.http_code, item.response.messages)?),
..item.data
})
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs" role="context" start="1204" end="1204">
use common_enums::enums;
use common_utils::{
errors::CustomResult,
ext_traits::{Encode, OptionExt, ValueExt},
request::Method,
};
use hyperswitch_domain_models::{
payment_method_data::{Card, PaymentMethodData, WalletData},
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::RSync,
router_request_types::ResponseId,
router_response_types::{
MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsCompleteAuthorizeRouterData, PaymentsSyncRouterData, RefundsRouterData,
SetupMandateRouterData,
},
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, CardData, ForeignTryFrom, PaymentsAuthorizeRequestData, PaymentsSyncRequestData,
RefundsRequestData, RouterData as OtherRouterData, WalletData as OtherWalletData,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs" role="context" start="1395" end="1430">
fn try_from(
item: &AuthorizedotnetRouterData<&RefundsRouterData<F>>,
) -> Result<Self, Self::Error> {
let payment_details = item
.router_data
.request
.connector_metadata
.as_ref()
.get_required_value("connector_metadata")
.change_context(errors::ConnectorError::MissingRequiredField {
field_name: "connector_metadata",
})?
.clone();
let merchant_authentication =
AuthorizedotnetAuthType::try_from(&item.router_data.connector_auth_type)?;
let transaction_request = RefundTransactionRequest {
transaction_type: TransactionType::Refund,
amount: item.amount,
payment: payment_details
.parse_value("PaymentDetails")
.change_context(errors::ConnectorError::MissingRequiredField {
field_name: "payment_details",
})?,
currency_code: item.router_data.request.currency.to_string(),
reference_transaction_id: item.router_data.request.connector_transaction_id.clone(),
};
Ok(Self {
create_transaction_request: AuthorizedotnetRefundRequest {
merchant_authentication,
transaction_request,
},
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs" role="context" start="1305" end="1365">
fn try_from(
item: ResponseRouterData<F, AuthorizedotnetVoidResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
match &item.response.transaction_response {
Some(transaction_response) => {
let status = enums::AttemptStatus::from(transaction_response.response_code.clone());
let error = transaction_response.errors.as_ref().and_then(|errors| {
errors.iter().next().map(|error| ErrorResponse {
code: error.error_code.clone(),
message: error.error_text.clone(),
reason: Some(error.error_text.clone()),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(transaction_response.transaction_id.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
});
let metadata = transaction_response
.account_number
.as_ref()
.map(|acc_no| {
construct_refund_payment_details(acc_no.clone().expose()).encode_to_value()
})
.transpose()
.change_context(errors::ConnectorError::MissingRequiredField {
field_name: "connector_metadata",
})?;
Ok(Self {
status,
response: match error {
Some(err) => Err(err),
None => Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
transaction_response.transaction_id.clone(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: metadata,
network_txn_id: transaction_response
.network_trans_id
.clone()
.map(|network_trans_id| network_trans_id.expose()),
connector_response_reference_id: Some(
transaction_response.transaction_id.clone(),
),
incremental_authorization_allowed: None,
charges: None,
}),
},
..item.data
})
}
None => Ok(Self {
status: enums::AttemptStatus::Failure,
response: Err(get_err_response(item.http_code, item.response.messages)?),
..item.data
}),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs" role="context" start="1187" end="1195">
fn from(item: AuthorizedotnetVoidStatus) -> Self {
match item {
AuthorizedotnetVoidStatus::Approved => Self::Voided,
AuthorizedotnetVoidStatus::Declined | AuthorizedotnetVoidStatus::Error => {
Self::VoidFailed
}
AuthorizedotnetVoidStatus::HeldForReview => Self::VoidInitiated,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs" role="context" start="1051" end="1068">
fn get_payment_status(
(item, auto_capture): (AuthorizedotnetPaymentStatus, bool),
) -> enums::AttemptStatus {
match item {
AuthorizedotnetPaymentStatus::Approved => {
if auto_capture {
enums::AttemptStatus::Charged
} else {
enums::AttemptStatus::Authorized
}
}
AuthorizedotnetPaymentStatus::Declined | AuthorizedotnetPaymentStatus::Error => {
enums::AttemptStatus::Failure
}
AuthorizedotnetPaymentStatus::RequiresAction => enums::AttemptStatus::AuthenticationPending,
AuthorizedotnetPaymentStatus::HeldForReview => enums::AttemptStatus::Pending,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs" role="context" start="776" end="822">
fn try_from(
(item, connector_mandate_id): (
&AuthorizedotnetRouterData<&PaymentsAuthorizeRouterData>,
api_models::payments::ConnectorMandateReferenceId,
),
) -> Result<Self, Self::Error> {
let mandate_id = connector_mandate_id
.get_connector_mandate_id()
.ok_or(errors::ConnectorError::MissingConnectorMandateID)?;
Ok(Self {
transaction_type: TransactionType::try_from(item.router_data.request.capture_method)?,
amount: item.amount,
currency_code: item.router_data.request.currency,
payment: None,
profile: mandate_id
.split_once('-')
.map(|(customer_profile_id, payment_profile_id)| {
ProfileDetails::CustomerProfileDetails(CustomerProfileDetails {
customer_profile_id: Secret::from(customer_profile_id.to_string()),
payment_profile: PaymentProfileDetails {
payment_profile_id: Secret::from(payment_profile_id.to_string()),
},
})
}),
order: Order {
description: item.router_data.connector_request_reference_id.clone(),
},
customer: None,
bill_to: None,
user_fields: match item.router_data.request.metadata.clone() {
Some(metadata) => Some(UserFields {
user_field: Vec::<UserField>::foreign_try_from(metadata)?,
}),
None => None,
},
processing_options: Some(ProcessingOptions {
is_subsequent_auth: true,
}),
subsequent_auth_information: None,
authorization_indicator_type: match item.router_data.request.capture_method {
Some(capture_method) => Some(AuthorizationIndicator {
authorization_indicator: capture_method.try_into()?,
}),
None => None,
},
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs" role="context" start="832" end="898">
fn try_from(
(item, ccard): (
&AuthorizedotnetRouterData<&PaymentsAuthorizeRouterData>,
&Card,
),
) -> Result<Self, Self::Error> {
let (profile, customer) = if item.router_data.request.is_mandate_payment() {
(
Some(ProfileDetails::CreateProfileDetails(CreateProfileDetails {
create_profile: true,
})),
Some(CustomerDetails {
//The payment ID is included in the customer details because the connector requires unique customer information with a length of fewer than 20 characters when creating a mandate.
//If the length exceeds 20 characters, a random alphanumeric string is used instead.
id: if item.router_data.payment_id.len() <= 20 {
item.router_data.payment_id.clone()
} else {
Alphanumeric.sample_string(&mut rand::thread_rng(), 20)
},
}),
)
} else {
(None, None)
};
Ok(Self {
transaction_type: TransactionType::try_from(item.router_data.request.capture_method)?,
amount: item.amount,
currency_code: item.router_data.request.currency,
payment: Some(PaymentDetails::CreditCard(CreditCardDetails {
card_number: (*ccard.card_number).clone(),
expiration_date: ccard.get_expiry_date_as_yyyymm("-"),
card_code: Some(ccard.card_cvc.clone()),
})),
profile,
order: Order {
description: item.router_data.connector_request_reference_id.clone(),
},
customer,
bill_to: item
.router_data
.get_optional_billing()
.and_then(|billing_address| billing_address.address.as_ref())
.map(|address| BillTo {
first_name: address.first_name.clone(),
last_name: address.last_name.clone(),
address: address.line1.clone(),
city: address.city.clone(),
state: address.state.clone(),
zip: address.zip.clone(),
country: address.country,
}),
user_fields: match item.router_data.request.metadata.clone() {
Some(metadata) => Some(UserFields {
user_field: Vec::<UserField>::foreign_try_from(metadata)?,
}),
None => None,
},
processing_options: None,
subsequent_auth_information: None,
authorization_indicator_type: match item.router_data.request.capture_method {
Some(capture_method) => Some(AuthorizationIndicator {
authorization_indicator: capture_method.try_into()?,
}),
None => None,
},
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs" role="context" start="1829" end="1838">
fn from(event_type: AuthorizedotnetWebhookEvent) -> Self {
match event_type {
AuthorizedotnetWebhookEvent::AuthorizationCreated => Self::AuthorizedPendingCapture,
AuthorizedotnetWebhookEvent::CaptureCreated
| AuthorizedotnetWebhookEvent::AuthCapCreated => Self::CapturedPendingSettlement,
AuthorizedotnetWebhookEvent::PriorAuthCapture => Self::SettledSuccessfully,
AuthorizedotnetWebhookEvent::VoidCreated => Self::Voided,
AuthorizedotnetWebhookEvent::RefundCreated => Self::RefundSettledSuccessfully,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs" role="context" start="64" end="64">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs" role="context" start="1142" end="1146">
pub struct AuthorizedotnetPaymentsResponse {
pub transaction_response: Option<TransactionResponse>,
pub profile_response: Option<AuthorizedotnetNonZeroMandateResponse>,
pub messages: ResponseMessages,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/aci/transformers.rs" role="context" start="642" end="642">
type Err = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/api_models/src/payment_methods.rs" role="context" start="2478" end="2478">
type Error = error_stack::Report<errors::ValidationError>;
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/coingate.rs<|crate|> hyperswitch_connectors<|connector|> coingate anchor=new kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/coingate.rs" role="context" start="56" end="60">
pub fn new() -> &'static Self {
&Self {
amount_converter: &StringMajorUnitForConnector,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/coingate.rs" role="context" start="55" end="55">
use common_utils::{
crypto,
errors::CustomResult,
ext_traits::{ByteSliceExt, BytesExt, ValueExt},
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, StringMajorUnit, StringMajorUnitForConnector},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/coingate.rs" role="context" start="101" end="103">
fn id(&self) -> &'static str {
"coingate"
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/coingate.rs" role="context" start="85" end="97">
fn build_headers(
&self,
req: &RouterData<Flow, Request, Response>,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
let mut header = vec![(
headers::CONTENT_TYPE.to_string(),
self.get_content_type().to_string().into(),
)];
let mut api_key = self.get_auth_header(&req.connector_auth_type)?;
header.append(&mut api_key);
Ok(header)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/coingate.rs" role="context" start="620" end="630">
fn get_webhook_resource_object(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<Box<dyn masking::ErasedMaskSerialize>, errors::ConnectorError> {
let notif: CoingateWebhookBody = request
.body
.parse_struct("CoingateWebhookBody")
.change_context(errors::ConnectorError::WebhookBodyDecodingFailed)?;
Ok(Box::new(notif))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/coingate.rs" role="context" start="385" end="398">
fn get_request_body(
&self,
req: &RefundsRouterData<Execute>,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let amount = utils::convert_amount(
self.amount_converter,
req.request.minor_refund_amount,
req.request.currency,
)?;
let connector_router_data = coingate::CoingateRouterData::from((amount, req));
let connector_req = coingate::CoingateRefundRequest::try_from(&connector_router_data)?;
Ok(RequestContent::FormUrlEncoded(Box::new(connector_req)))
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/hipay.rs<|crate|> hyperswitch_connectors<|connector|> hipay anchor=new kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/hipay.rs" role="context" start="80" end="84">
pub fn new() -> &'static Self {
&Self {
amount_converter: &StringMajorUnitForConnector,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/hipay.rs" role="context" start="79" end="79">
use common_utils::{
consts::BASE64_ENGINE,
errors::{self as common_errors, CustomResult},
ext_traits::BytesExt,
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, StringMajorUnit, StringMajorUnitForConnector},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/hipay.rs" role="context" start="111" end="120">
fn get_url(
&self,
_req: &TokenizationRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}v2/token/create",
connectors.hipay.secondary_base_url.clone()
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/hipay.rs" role="context" start="103" end="109">
fn get_headers(
&self,
req: &TokenizationRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/hipay.rs" role="context" start="49" end="73">
pub fn build_form_from_struct<T: Serialize>(data: T) -> Result<Form, common_errors::ParsingError> {
let mut form = Form::new();
let serialized = serde_json::to_value(&data).map_err(|e| {
router_env::logger::error!("Error serializing data to JSON value: {:?}", e);
common_errors::ParsingError::EncodeError("json-value")
})?;
let serialized_object = serialized.as_object().ok_or_else(|| {
router_env::logger::error!("Error: Expected JSON object but got something else");
common_errors::ParsingError::EncodeError("Expected object")
})?;
for (key, values) in serialized_object {
let value = match values {
Value::String(s) => s.clone(),
Value::Number(n) => n.to_string(),
Value::Bool(b) => b.to_string(),
Value::Null => "".to_string(),
Value::Array(_) | Value::Object(_) => {
router_env::logger::error!(serialization_error =? "Form Construction Failed.");
"".to_string()
}
};
form = form.text(key.clone(), value.clone());
}
Ok(form)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/hipay.rs" role="context" start="545" end="559">
fn build_request(
&self,
req: &PaymentsCancelRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsVoidType::get_url(self, req, connectors)?)
.headers(types::PaymentsVoidType::get_headers(self, req, connectors)?)
.set_body(types::PaymentsVoidType::get_request_body(
self, req, connectors,
)?)
.build();
Ok(Some(request))
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet.rs<|crate|> hyperswitch_connectors<|connector|> authorizedotnet anchor=get_url kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet.rs" role="context" start="792" end="798">
fn get_url(
&self,
_req: &PaymentsCompleteAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(self.base_url(connectors).to_string())
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet.rs" role="context" start="791" end="791">
fn get_headers(
&self,
req: &PaymentsCompleteAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
&self,
_req: &PaymentsCompleteAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(self.base_url(connectors).to_string())
}
fn get_request_body(
&self,
req: &PaymentsCompleteAuthorizeRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let connector_router_data = authorizedotnet::AuthorizedotnetRouterData::try_from((
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet.rs" role="context" start="816" end="836">
fn build_request(
&self,
req: &PaymentsCompleteAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&PaymentsCompleteAuthorizeType::get_url(
self, req, connectors,
)?)
.attach_default_headers()
.headers(PaymentsCompleteAuthorizeType::get_headers(
self, req, connectors,
)?)
.set_body(PaymentsCompleteAuthorizeType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet.rs" role="context" start="799" end="814">
fn get_request_body(
&self,
req: &PaymentsCompleteAuthorizeRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let connector_router_data = authorizedotnet::AuthorizedotnetRouterData::try_from((
&self.get_currency_unit(),
req.request.currency,
req.request.amount,
req,
))?;
let connector_req =
authorizedotnet::PaypalConfirmRequest::try_from(&connector_router_data)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet.rs" role="context" start="788" end="790">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet.rs" role="context" start="780" end="786">
fn get_headers(
&self,
req: &PaymentsCompleteAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet.rs" role="context" start="186" end="200">
fn build_request(
&self,
req: &SetupMandateRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&SetupMandateType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(SetupMandateType::get_headers(self, req, connectors)?)
.set_body(SetupMandateType::get_request_body(self, req, connectors)?)
.build(),
))
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/square.rs<|crate|> hyperswitch_connectors<|connector|> square anchor=get_headers kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/square.rs" role="context" start="755" end="761">
fn get_headers(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/square.rs" role="context" start="754" end="754">
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
}
impl ConnectorIntegration<RSync, RefundsData, RefundsResponseData> for Square {
fn get_headers(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/square.rs" role="context" start="767" end="777">
fn get_url(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}v2/refunds/{}",
self.base_url(connectors),
req.request.get_connector_refund_id()?,
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/square.rs" role="context" start="763" end="765">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/square.rs" role="context" start="745" end="751">
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/square.rs" role="context" start="724" end="743">
fn handle_response(
&self,
data: &RefundsRouterData<Execute>,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundsRouterData<Execute>, errors::ConnectorError> {
let response: square::RefundResponse = res
.response
.parse_struct("SquareRefundResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/square.rs" role="context" start="552" end="573">
fn build_request(
&self,
req: &PaymentsCaptureRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
if req.request.amount_to_capture != req.request.payment_amount {
Err(errors::ConnectorError::NotSupported {
message: "Partial Capture".to_string(),
connector: "Square",
})?
}
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsCaptureType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsCaptureType::get_headers(
self, req, connectors,
)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/square.rs" role="context" start="705" end="722">
fn build_request(
&self,
req: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Post)
.url(&types::RefundExecuteType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::RefundExecuteType::get_headers(
self, req, connectors,
)?)
.set_body(types::RefundExecuteType::get_request_body(
self, req, connectors,
)?)
.build();
Ok(Some(request))
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet.rs<|crate|> hyperswitch_connectors<|connector|> authorizedotnet anchor=get_headers kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet.rs" role="context" start="780" end="786">
fn get_headers(
&self,
req: &PaymentsCompleteAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet.rs" role="context" start="779" end="779">
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
get_error_response(res, event_builder)
}
}
impl api::PaymentsCompleteAuthorize for Authorizedotnet {}
impl ConnectorIntegration<CompleteAuthorize, CompleteAuthorizeData, PaymentsResponseData>
for Authorizedotnet
{
fn get_headers(
&self,
req: &PaymentsCompleteAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet.rs" role="context" start="792" end="798">
fn get_url(
&self,
_req: &PaymentsCompleteAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(self.base_url(connectors).to_string())
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet.rs" role="context" start="788" end="790">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet.rs" role="context" start="766" end="772">
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
get_error_response(res, event_builder)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet.rs" role="context" start="740" end="764">
fn handle_response(
&self,
data: &RefundsRouterData<RSync>,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundsRouterData<RSync>, errors::ConnectorError> {
use bytes::Buf;
// Handle the case where response bytes contains U+FEFF (BOM) character sent by connector
let encoding = encoding_rs::UTF_8;
let intermediate_response = encoding.decode_with_bom_removal(res.response.chunk());
let intermediate_response =
bytes::Bytes::copy_from_slice(intermediate_response.0.as_bytes());
let response: authorizedotnet::AuthorizedotnetRSyncResponse = intermediate_response
.parse_struct("AuthorizedotnetRSyncResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet.rs" role="context" start="636" end="649">
fn build_request(
&self,
req: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Post)
.url(&RefundExecuteType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(RefundExecuteType::get_headers(self, req, connectors)?)
.set_body(RefundExecuteType::get_request_body(self, req, connectors)?)
.build();
Ok(Some(request))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet.rs" role="context" start="186" end="200">
fn build_request(
&self,
req: &SetupMandateRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&SetupMandateType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(SetupMandateType::get_headers(self, req, connectors)?)
.set_body(SetupMandateType::get_request_body(self, req, connectors)?)
.build(),
))
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/worldpay.rs<|crate|> hyperswitch_connectors<|connector|> worldpay anchor=get_headers kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/worldpay.rs" role="context" start="1011" end="1017">
fn get_headers(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/worldpay.rs" role="context" start="1010" end="1010">
}
fn get_5xx_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
}
impl ConnectorIntegration<RSync, RefundsData, RefundsResponseData> for Worldpay {
fn get_headers(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/worldpay.rs" role="context" start="1023" end="1033">
fn get_url(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}api/payments/{}",
self.base_url(connectors),
urlencoding::encode(&req.request.get_connector_refund_id()?),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/worldpay.rs" role="context" start="1019" end="1021">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/worldpay.rs" role="context" start="1001" end="1007">
fn get_5xx_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/worldpay.rs" role="context" start="993" end="999">
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/worldpay.rs" role="context" start="828" end="846">
fn build_request(
&self,
req: &PaymentsCompleteAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsCompleteAuthorizeType::get_url(
self, req, connectors,
)?)
.headers(types::PaymentsCompleteAuthorizeType::get_headers(
self, req, connectors,
)?)
.set_body(types::PaymentsCompleteAuthorizeType::get_request_body(
self, req, connectors,
)?)
.build();
Ok(Some(request))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/worldpay.rs" role="context" start="451" end="464">
fn build_request(
&self,
req: &PaymentsSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&types::PaymentsSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsSyncType::get_headers(self, req, connectors)?)
.build(),
))
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/bluesnap.rs<|crate|> hyperswitch_connectors<|connector|> bluesnap anchor=get_headers kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bluesnap.rs" role="context" start="986" end="992">
fn get_headers(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bluesnap.rs" role="context" start="985" end="985">
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
}
impl ConnectorIntegration<RSync, RefundsData, RefundsResponseData> for Bluesnap {
fn get_headers(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bluesnap.rs" role="context" start="998" end="1025">
fn get_url(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
if req.request.payment_amount == req.request.refund_amount {
let meta_data: CustomResult<
bluesnap::BluesnapConnectorMetaData,
errors::ConnectorError,
> = to_connector_meta_from_secret(req.connector_meta_data.clone());
match meta_data {
// if merchant_id is present, rsync can be made using merchant_transaction_id
Ok(data) => get_url_with_merchant_transaction_id(
self.base_url(connectors).to_string(),
data.merchant_id,
req.attempt_id.to_owned(),
),
// otherwise rsync is made using connector_transaction_id
Err(_) => get_rsync_url_with_connector_refund_id(
req,
self.base_url(connectors).to_string(),
),
}
} else {
get_rsync_url_with_connector_refund_id(req, self.base_url(connectors).to_string())
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bluesnap.rs" role="context" start="994" end="996">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bluesnap.rs" role="context" start="976" end="982">
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bluesnap.rs" role="context" start="956" end="974">
fn handle_response(
&self,
data: &RefundsRouterData<Execute>,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundsRouterData<Execute>, errors::ConnectorError> {
let response: bluesnap::RefundResponse = res
.response
.parse_struct("bluesnap RefundResponse")
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bluesnap.rs" role="context" start="429" end="442">
fn build_request(
&self,
req: &PaymentsSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&types::PaymentsSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsSyncType::get_headers(self, req, connectors)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bluesnap.rs" role="context" start="1027" end="1040">
fn build_request(
&self,
req: &RefundsRouterData<RSync>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&types::RefundSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::RefundSyncType::get_headers(self, req, connectors)?)
.build(),
))
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/globalpay.rs<|crate|> hyperswitch_connectors<|connector|> globalpay anchor=get_headers kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globalpay.rs" role="context" start="871" end="877">
fn get_headers(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globalpay.rs" role="context" start="870" end="870">
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
}
impl ConnectorIntegration<RSync, RefundsData, RefundsResponseData> for Globalpay {
fn get_headers(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globalpay.rs" role="context" start="883" end="894">
fn get_url(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let refund_id = req.request.get_connector_refund_id()?;
Ok(format!(
"{}transactions/{}",
self.base_url(connectors),
refund_id
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globalpay.rs" role="context" start="879" end="881">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globalpay.rs" role="context" start="861" end="867">
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globalpay.rs" role="context" start="839" end="859">
fn handle_response(
&self,
data: &RefundsRouterData<Execute>,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundsRouterData<Execute>, errors::ConnectorError> {
let response: GlobalpayPaymentsResponse = res
.response
.parse_struct("globalpay RefundResponse")
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globalpay.rs" role="context" start="537" end="550">
fn build_request(
&self,
req: &PaymentsSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&PaymentsSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(PaymentsSyncType::get_headers(self, req, connectors)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globalpay.rs" role="context" start="638" end="654">
fn build_request(
&self,
req: &PaymentsCaptureRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&PaymentsCaptureType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(PaymentsCaptureType::get_headers(self, req, connectors)?)
.set_body(PaymentsCaptureType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys.rs<|crate|> hyperswitch_connectors<|connector|> redsys anchor=get_url kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys.rs" role="context" start="733" end="742">
fn get_url(
&self,
_req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}/apl02/services/SerClsWSConsulta",
self.base_url(connectors)
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys.rs" role="context" start="732" end="732">
impl ConnectorIntegration<RSync, RefundsData, RefundsResponseData> for Redsys {
fn get_headers(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
&self,
_req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}/apl02/services/SerClsWSConsulta",
self.base_url(connectors)
))
}
fn get_request_body(
&self,
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys.rs" role="context" start="753" end="767">
fn build_request(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&RefundSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(RefundSyncType::get_headers(self, req, connectors)?)
.set_body(self.get_request_body(req, connectors)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys.rs" role="context" start="744" end="751">
fn get_request_body(
&self,
req: &RefundSyncRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let connector_req = redsys::build_refund_sync_request(req)?;
Ok(RequestContent::RawBytes(connector_req))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys.rs" role="context" start="730" end="732">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys.rs" role="context" start="723" end="729">
fn get_headers(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys.rs" role="context" start="601" end="615">
fn build_request(
&self,
req: &RefundExecuteRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&RefundExecuteType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(RefundExecuteType::get_headers(self, req, connectors)?)
.set_body(self.get_request_body(req, connectors)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys.rs" role="context" start="289" end="302">
fn build_request(
&self,
req: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Post)
.url(&PaymentsAuthorizeType::get_url(self, req, connectors)?)
.attach_default_headers()
.set_body(self.get_request_body(req, connectors)?)
.build();
Ok(Some(request))
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei.rs<|crate|> hyperswitch_connectors<|connector|> nuvei anchor=get_url kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei.rs" role="context" start="771" end="780">
fn get_url(
&self,
_req: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}ppp/api/v1/refundTransaction.do",
ConnectorCommon::base_url(self, connectors)
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei.rs" role="context" start="770" end="770">
fn get_headers(
&self,
req: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
&self,
_req: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}ppp/api/v1/refundTransaction.do",
ConnectorCommon::base_url(self, connectors)
))
}
fn get_request_body(
&self,
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei.rs" role="context" start="791" end="808">
fn build_request(
&self,
req: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Post)
.url(&types::RefundExecuteType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::RefundExecuteType::get_headers(
self, req, connectors,
)?)
.set_body(types::RefundExecuteType::get_request_body(
self, req, connectors,
)?)
.build();
Ok(Some(request))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei.rs" role="context" start="782" end="789">
fn get_request_body(
&self,
req: &RefundsRouterData<Execute>,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let connector_req = nuvei::NuveiPaymentFlowRequest::try_from(req)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei.rs" role="context" start="767" end="769">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei.rs" role="context" start="759" end="765">
fn get_headers(
&self,
req: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei.rs" role="context" start="705" end="725">
fn build_request(
&self,
req: &PaymentsPreProcessingRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsPreProcessingType::get_url(
self, req, connectors,
)?)
.attach_default_headers()
.headers(types::PaymentsPreProcessingType::get_headers(
self, req, connectors,
)?)
.set_body(types::PaymentsPreProcessingType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei.rs" role="context" start="281" end="296">
fn build_request(
&self,
req: &PaymentsCancelRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsVoidType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsVoidType::get_headers(self, req, connectors)?)
.set_body(types::PaymentsVoidType::get_request_body(
self, req, connectors,
)?)
.build();
Ok(Some(request))
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/checkout.rs<|crate|> hyperswitch_connectors<|connector|> checkout anchor=get_request_body kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/checkout.rs" role="context" start="1063" end="1070">
fn get_request_body(
&self,
req: &SubmitEvidenceRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let connector_req = checkout::Evidence::try_from(req)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/checkout.rs" role="context" start="1062" end="1062">
fn get_url(
&self,
req: &SubmitEvidenceRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}disputes/{}/evidence",
self.base_url(connectors),
req.request.connector_dispute_id,
))
}
fn get_request_body(
&self,
req: &SubmitEvidenceRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let connector_req = checkout::Evidence::try_from(req)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
fn build_request(
&self,
req: &SubmitEvidenceRouterData,
connectors: &Connectors,
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/checkout.rs" role="context" start="1087" end="1100">
fn handle_response(
&self,
data: &SubmitEvidenceRouterData,
_event_builder: Option<&mut ConnectorEvent>,
_res: Response,
) -> CustomResult<SubmitEvidenceRouterData, errors::ConnectorError> {
Ok(SubmitEvidenceRouterData {
response: Ok(SubmitEvidenceResponse {
dispute_status: api_models::enums::DisputeStatus::DisputeChallenged,
connector_status: None,
}),
..data.clone()
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/checkout.rs" role="context" start="1072" end="1085">
fn build_request(
&self,
req: &SubmitEvidenceRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Put)
.url(&SubmitEvidenceType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(SubmitEvidenceType::get_headers(self, req, connectors)?)
.set_body(SubmitEvidenceType::get_request_body(self, req, connectors)?)
.build();
Ok(Some(request))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/checkout.rs" role="context" start="1051" end="1061">
fn get_url(
&self,
req: &SubmitEvidenceRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}disputes/{}/evidence",
self.base_url(connectors),
req.request.connector_dispute_id,
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/checkout.rs" role="context" start="1035" end="1049">
fn get_headers(
&self,
req: &SubmitEvidenceRouterData,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
let mut header = vec![(
headers::CONTENT_TYPE.to_string(),
SubmitEvidenceType::get_content_type(self)
.to_string()
.into(),
)];
let mut api_key = self.get_auth_header(&req.connector_auth_type)?;
header.append(&mut api_key);
Ok(header)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/checkout.rs" role="context" start="377" end="393">
fn build_request(
&self,
req: &PaymentsCaptureRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&PaymentsCaptureType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(PaymentsCaptureType::get_headers(self, req, connectors)?)
.set_body(PaymentsCaptureType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/checkout.rs" role="context" start="559" end="575">
fn build_request(
&self,
req: &RouterData<Authorize, PaymentsAuthorizeData, PaymentsResponseData>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&PaymentsAuthorizeType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(PaymentsAuthorizeType::get_headers(self, req, connectors)?)
.set_body(PaymentsAuthorizeType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/checkout.rs" role="context" start="75" end="79">
pub fn new() -> &'static Self {
&Self {
amount_converter: &MinorUnitForConnector,
}
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/square.rs<|crate|> hyperswitch_connectors<|connector|> square anchor=get_url kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/square.rs" role="context" start="767" end="777">
fn get_url(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}v2/refunds/{}",
self.base_url(connectors),
req.request.get_connector_refund_id()?,
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/square.rs" role="context" start="766" end="766">
fn get_headers(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}v2/refunds/{}",
self.base_url(connectors),
req.request.get_connector_refund_id()?,
))
}
fn build_request(
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/square.rs" role="context" start="794" end="813">
fn handle_response(
&self,
data: &RefundSyncRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundSyncRouterData, errors::ConnectorError> {
let response: square::RefundResponse = res
.response
.parse_struct("SquareRefundSyncResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/square.rs" role="context" start="779" end="792">
fn build_request(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&types::RefundSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::RefundSyncType::get_headers(self, req, connectors)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/square.rs" role="context" start="763" end="765">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/square.rs" role="context" start="755" end="761">
fn get_headers(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/square.rs" role="context" start="235" end="251">
fn build_request(
&self,
req: &TokenizationRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::TokenizationType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::TokenizationType::get_headers(self, req, connectors)?)
.set_body(types::TokenizationType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/novalnet.rs<|crate|> hyperswitch_connectors<|connector|> novalnet anchor=get_request_body kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/novalnet.rs" role="context" start="736" end="743">
fn get_request_body(
&self,
req: &PaymentsCancelRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let connector_req = novalnet::NovalnetCancelRequest::try_from(req)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/novalnet.rs" role="context" start="735" end="735">
self.common_get_content_type()
}
fn get_url(
&self,
_req: &PaymentsCancelRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let endpoint = self.base_url(connectors);
Ok(format!("{}/transaction/cancel", endpoint))
}
fn get_request_body(
&self,
req: &PaymentsCancelRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let connector_req = novalnet::NovalnetCancelRequest::try_from(req)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
fn build_request(
&self,
req: &PaymentsCancelRouterData,
connectors: &Connectors,
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/novalnet.rs" role="context" start="763" end="782">
fn handle_response(
&self,
data: &PaymentsCancelRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsCancelRouterData, errors::ConnectorError> {
let response: novalnet::NovalnetCancelResponse = res
.response
.parse_struct("NovalnetPaymentsVoidResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/novalnet.rs" role="context" start="745" end="761">
fn build_request(
&self,
req: &PaymentsCancelRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsVoidType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsVoidType::get_headers(self, req, connectors)?)
.set_body(types::PaymentsVoidType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/novalnet.rs" role="context" start="727" end="734">
fn get_url(
&self,
_req: &PaymentsCancelRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let endpoint = self.base_url(connectors);
Ok(format!("{}/transaction/cancel", endpoint))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/novalnet.rs" role="context" start="723" end="725">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/novalnet.rs" role="context" start="590" end="607">
fn build_request(
&self,
req: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Post)
.url(&types::RefundExecuteType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::RefundExecuteType::get_headers(
self, req, connectors,
)?)
.set_body(types::RefundExecuteType::get_request_body(
self, req, connectors,
)?)
.build();
Ok(Some(request))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/novalnet.rs" role="context" start="339" end="359">
fn build_request(
&self,
req: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsAuthorizeType::get_url(
self, req, connectors,
)?)
.attach_default_headers()
.headers(types::PaymentsAuthorizeType::get_headers(
self, req, connectors,
)?)
.set_body(types::PaymentsAuthorizeType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/novalnet.rs" role="context" start="63" end="67">
pub fn new() -> &'static Self {
&Self {
amount_converter: &StringMinorUnitForConnector,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs" role="context" start="1260" end="1263">
pub struct NovalnetCancelRequest {
pub transaction: NovalnetCancelTransaction,
pub custom: NovalnetCustom,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/worldpay.rs<|crate|> hyperswitch_connectors<|connector|> worldpay anchor=get_url kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/worldpay.rs" role="context" start="1023" end="1033">
fn get_url(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}api/payments/{}",
self.base_url(connectors),
urlencoding::encode(&req.request.get_connector_refund_id()?),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/worldpay.rs" role="context" start="1022" end="1022">
fn get_headers(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}api/payments/{}",
self.base_url(connectors),
urlencoding::encode(&req.request.get_connector_refund_id()?),
))
}
fn build_request(
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/worldpay.rs" role="context" start="1050" end="1069">
fn handle_response(
&self,
data: &RefundSyncRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundSyncRouterData, errors::ConnectorError> {
let response: WorldpayEventResponse =
res.response
.parse_struct("Worldpay EventResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
Ok(RefundSyncRouterData {
response: Ok(RefundsResponseData {
connector_refund_id: data.request.refund_id.clone(),
refund_status: enums::RefundStatus::from(response.last_event),
}),
..data.clone()
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/worldpay.rs" role="context" start="1035" end="1048">
fn build_request(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&types::RefundSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::RefundSyncType::get_headers(self, req, connectors)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/worldpay.rs" role="context" start="1019" end="1021">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/worldpay.rs" role="context" start="1011" end="1017">
fn get_headers(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/worldpay.rs" role="context" start="243" end="259">
fn build_request(
&self,
req: &SetupMandateRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::SetupMandateType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::SetupMandateType::get_headers(self, req, connectors)?)
.set_body(types::SetupMandateType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/worldpay.rs" role="context" start="938" end="955">
fn build_request(
&self,
req: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Post)
.url(&types::RefundExecuteType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::RefundExecuteType::get_headers(
self, req, connectors,
)?)
.set_body(types::RefundExecuteType::get_request_body(
self, req, connectors,
)?)
.build();
Ok(Some(request))
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/globalpay.rs<|crate|> hyperswitch_connectors<|connector|> globalpay anchor=get_url kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globalpay.rs" role="context" start="883" end="894">
fn get_url(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let refund_id = req.request.get_connector_refund_id()?;
Ok(format!(
"{}transactions/{}",
self.base_url(connectors),
refund_id
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globalpay.rs" role="context" start="882" end="882">
fn get_headers(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let refund_id = req.request.get_connector_refund_id()?;
Ok(format!(
"{}transactions/{}",
self.base_url(connectors),
refund_id
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globalpay.rs" role="context" start="911" end="931">
fn handle_response(
&self,
data: &RefundSyncRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundSyncRouterData, errors::ConnectorError> {
let response: GlobalpayPaymentsResponse = res
.response
.parse_struct("globalpay RefundResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globalpay.rs" role="context" start="896" end="909">
fn build_request(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&RefundSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(RefundSyncType::get_headers(self, req, connectors)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globalpay.rs" role="context" start="879" end="881">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globalpay.rs" role="context" start="871" end="877">
fn get_headers(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globalpay.rs" role="context" start="442" end="456">
fn build_request(
&self,
req: &PaymentsCancelRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&PaymentsVoidType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(PaymentsVoidType::get_headers(self, req, connectors)?)
.set_body(PaymentsVoidType::get_request_body(self, req, connectors)?)
.build(),
))
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei.rs<|crate|> hyperswitch_connectors<|connector|> nuvei anchor=get_request_body kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei.rs" role="context" start="782" end="789">
fn get_request_body(
&self,
req: &RefundsRouterData<Execute>,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let connector_req = nuvei::NuveiPaymentFlowRequest::try_from(req)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei.rs" role="context" start="781" end="781">
fn get_url(
&self,
_req: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}ppp/api/v1/refundTransaction.do",
ConnectorCommon::base_url(self, connectors)
))
}
fn get_request_body(
&self,
req: &RefundsRouterData<Execute>,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let connector_req = nuvei::NuveiPaymentFlowRequest::try_from(req)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
fn build_request(
&self,
req: &RefundsRouterData<Execute>,
connectors: &Connectors,
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei.rs" role="context" start="810" end="830">
fn handle_response(
&self,
data: &RefundsRouterData<Execute>,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundsRouterData<Execute>, errors::ConnectorError> {
let response: nuvei::NuveiPaymentsResponse = res
.response
.parse_struct("NuveiPaymentsResponse")
.switch()?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei.rs" role="context" start="791" end="808">
fn build_request(
&self,
req: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Post)
.url(&types::RefundExecuteType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::RefundExecuteType::get_headers(
self, req, connectors,
)?)
.set_body(types::RefundExecuteType::get_request_body(
self, req, connectors,
)?)
.build();
Ok(Some(request))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei.rs" role="context" start="771" end="780">
fn get_url(
&self,
_req: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}ppp/api/v1/refundTransaction.do",
ConnectorCommon::base_url(self, connectors)
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei.rs" role="context" start="767" end="769">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei.rs" role="context" start="361" end="377">
fn build_request(
&self,
req: &PaymentsSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsSyncType::get_headers(self, req, connectors)?)
.set_body(types::PaymentsSyncType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei.rs" role="context" start="443" end="461">
fn build_request(
&self,
req: &PaymentsCaptureRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsCaptureType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsCaptureType::get_headers(
self, req, connectors,
)?)
.set_body(types::PaymentsCaptureType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nuvei/transformers.rs" role="context" start="268" end="277">
pub struct NuveiPaymentFlowRequest {
pub time_stamp: String,
pub merchant_id: Secret<String>,
pub merchant_site_id: Secret<String>,
pub client_request_id: String,
pub amount: String,
pub currency: enums::Currency,
pub related_transaction_id: Option<String>,
pub checksum: Secret<String>,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/klarna.rs<|crate|> hyperswitch_connectors<|connector|> klarna anchor=get_url kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/klarna.rs" role="context" start="1291" end="1304">
fn get_url(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let order_id = req.request.connector_transaction_id.clone();
let refund_id = req.request.get_connector_refund_id()?;
let endpoint =
build_region_specific_endpoint(self.base_url(connectors), &req.connector_meta_data)?;
Ok(format!(
"{endpoint}ordermanagement/v1/orders/{order_id}/refunds/{refund_id}"
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/klarna.rs" role="context" start="1290" end="1290">
use common_utils::{
consts::BASE64_ENGINE,
errors::CustomResult,
ext_traits::BytesExt,
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, MinorUnit, MinorUnitForConnector},
};
use hyperswitch_domain_models::{
payment_method_data::{PayLaterData, PaymentMethodData},
router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::{
access_token_auth::AccessTokenAuth,
payments::{Authorize, Capture, PSync, PaymentMethodToken, Session, SetupMandate, Void},
refunds::{Execute, RSync},
},
router_request_types::{
AccessTokenRequestData, PaymentMethodTokenizationData, PaymentsAuthorizeData,
PaymentsCancelData, PaymentsCaptureData, PaymentsSessionData, PaymentsSyncData,
RefundsData, SetupMandateRequestData,
},
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsSessionRouterData, PaymentsSyncRouterData, RefundSyncRouterData, RefundsRouterData,
},
};
use hyperswitch_interfaces::{
api::{
self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorSpecifications,
ConnectorValidation,
},
configs::Connectors,
consts::NO_ERROR_MESSAGE,
errors,
events::connector_api_logs::ConnectorEvent,
types::{self, Response},
webhooks::{IncomingWebhook, IncomingWebhookRequestDetails},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/klarna.rs" role="context" start="1320" end="1337">
fn handle_response(
&self,
data: &RefundSyncRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundSyncRouterData, errors::ConnectorError> {
let response: klarna::KlarnaRefundSyncResponse = res
.response
.parse_struct("klarna KlarnaRefundSyncResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/klarna.rs" role="context" start="1306" end="1318">
fn build_request(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&types::RefundSyncType::get_url(self, req, connectors)?)
.headers(types::RefundSyncType::get_headers(self, req, connectors)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/klarna.rs" role="context" start="1287" end="1289">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/klarna.rs" role="context" start="1279" end="1285">
fn get_headers(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/klarna.rs" role="context" start="1054" end="1074">
fn build_request(
&self,
req: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsAuthorizeType::get_url(
self, req, connectors,
)?)
.attach_default_headers()
.headers(types::PaymentsAuthorizeType::get_headers(
self, req, connectors,
)?)
.set_body(types::PaymentsAuthorizeType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/klarna.rs" role="context" start="362" end="379">
fn build_request(
&self,
req: &PaymentsCaptureRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsCaptureType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsCaptureType::get_headers(
self, req, connectors,
)?)
.set_body(types::PaymentsCaptureType::get_request_body(
self, req, connectors,
)?)
.build();
Ok(Some(request))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/klarna.rs" role="context" start="196" end="210">
fn build_region_specific_endpoint(
base_url: &str,
connector_metadata: &Option<common_utils::pii::SecretSerdeValue>,
) -> CustomResult<String, errors::ConnectorError> {
let klarna_metadata_object =
transformers::KlarnaConnectorMetadataObject::try_from(connector_metadata)?;
let klarna_region = klarna_metadata_object
.klarna_region
.ok_or(errors::ConnectorError::InvalidConnectorConfig {
config: "merchant_connector_account.metadata.klarna_region",
})
.map(String::from)?;
Ok(base_url.replace("{{klarna_region}}", &klarna_region))
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet.rs<|crate|> hyperswitch_connectors<|connector|> authorizedotnet anchor=get_request_body kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet.rs" role="context" start="799" end="814">
fn get_request_body(
&self,
req: &PaymentsCompleteAuthorizeRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let connector_router_data = authorizedotnet::AuthorizedotnetRouterData::try_from((
&self.get_currency_unit(),
req.request.currency,
req.request.amount,
req,
))?;
let connector_req =
authorizedotnet::PaypalConfirmRequest::try_from(&connector_router_data)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet.rs" role="context" start="798" end="798">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
&self,
_req: &PaymentsCompleteAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(self.base_url(connectors).to_string())
}
fn get_request_body(
&self,
req: &PaymentsCompleteAuthorizeRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let connector_router_data = authorizedotnet::AuthorizedotnetRouterData::try_from((
&self.get_currency_unit(),
req.request.currency,
req.request.amount,
req,
))?;
let connector_req =
authorizedotnet::PaypalConfirmRequest::try_from(&connector_router_data)?;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet.rs" role="context" start="838" end="865">
fn handle_response(
&self,
data: &PaymentsCompleteAuthorizeRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsCompleteAuthorizeRouterData, errors::ConnectorError> {
use bytes::Buf;
// Handle the case where response bytes contains U+FEFF (BOM) character sent by connector
let encoding = encoding_rs::UTF_8;
let intermediate_response = encoding.decode_with_bom_removal(res.response.chunk());
let intermediate_response =
bytes::Bytes::copy_from_slice(intermediate_response.0.as_bytes());
let response: authorizedotnet::AuthorizedotnetPaymentsResponse = intermediate_response
.parse_struct("AuthorizedotnetPaymentsResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::foreign_try_from((
ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
},
data.request.is_auto_capture()?,
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet.rs" role="context" start="816" end="836">
fn build_request(
&self,
req: &PaymentsCompleteAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&PaymentsCompleteAuthorizeType::get_url(
self, req, connectors,
)?)
.attach_default_headers()
.headers(PaymentsCompleteAuthorizeType::get_headers(
self, req, connectors,
)?)
.set_body(PaymentsCompleteAuthorizeType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet.rs" role="context" start="792" end="798">
fn get_url(
&self,
_req: &PaymentsCompleteAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(self.base_url(connectors).to_string())
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet.rs" role="context" start="788" end="790">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet.rs" role="context" start="636" end="649">
fn build_request(
&self,
req: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Post)
.url(&RefundExecuteType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(RefundExecuteType::get_headers(self, req, connectors)?)
.set_body(RefundExecuteType::get_request_body(self, req, connectors)?)
.build();
Ok(Some(request))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet.rs" role="context" start="186" end="200">
fn build_request(
&self,
req: &SetupMandateRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&SetupMandateType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(SetupMandateType::get_headers(self, req, connectors)?)
.set_body(SetupMandateType::get_request_body(self, req, connectors)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs" role="context" start="1922" end="1924">
pub struct PaypalConfirmRequest {
create_transaction_request: PaypalConfirmTransactionRequest,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs<|crate|> hyperswitch_connectors<|connector|> adyen anchor=get_webhook_object_from_body kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs" role="context" start="1694" end="1707">
fn get_webhook_object_from_body(
body: &[u8],
) -> CustomResult<adyen::AdyenNotificationRequestItemWH, common_utils::errors::ParsingError> {
let mut webhook: adyen::AdyenIncomingWebhook = body.parse_struct("AdyenIncomingWebhook")?;
let item_object = webhook
.notification_items
.drain(..)
.next()
// TODO: ParsingError doesn't seem to be an apt error for this case
.ok_or(common_utils::errors::ParsingError::UnknownError)?;
Ok(item_object.notification_request_item)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs" role="context" start="1693" end="1693">
use common_utils::{
consts,
errors::CustomResult,
ext_traits::{ByteSliceExt, OptionExt},
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, MinorUnit, MinorUnitForConnector},
};
use hyperswitch_interfaces::{
api::{
self,
disputes::{AcceptDispute, DefendDispute, Dispute, SubmitEvidence},
files::{FilePurpose, FileUpload, RetrieveFile, UploadFile},
CaptureSyncMethod, ConnectorCommon, ConnectorIntegration, ConnectorSpecifications,
ConnectorValidation,
},
configs::Connectors,
consts::{NO_ERROR_CODE, NO_ERROR_MESSAGE},
disputes, errors,
events::connector_api_logs::ConnectorEvent,
types::{
AcceptDisputeType, DefendDisputeType, PaymentsAuthorizeType, PaymentsCaptureType,
PaymentsPreProcessingType, PaymentsSyncType, PaymentsVoidType, RefundExecuteType, Response,
SetupMandateType, SubmitEvidenceType,
},
webhooks::{IncomingWebhook, IncomingWebhookFlowError, IncomingWebhookRequestDetails},
};
use transformers as adyen;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs" role="context" start="1719" end="1729">
fn get_webhook_source_verification_signature(
&self,
request: &IncomingWebhookRequestDetails<'_>,
_connector_webhook_secrets: &api_models::webhooks::ConnectorWebhookSecrets,
) -> CustomResult<Vec<u8>, errors::ConnectorError> {
let notif_item = get_webhook_object_from_body(request.body)
.change_context(errors::ConnectorError::WebhookSourceVerificationFailed)?;
let base64_signature = notif_item.additional_data.hmac_signature.expose();
Ok(base64_signature.as_bytes().to_vec())
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs" role="context" start="1711" end="1717">
fn get_webhook_source_verification_algorithm(
&self,
_request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<Box<dyn common_utils::crypto::VerifySignature + Send>, errors::ConnectorError>
{
Ok(Box::new(common_utils::crypto::HmacSha256))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs" role="context" start="1683" end="1689">
fn get_5xx_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs" role="context" start="1676" end="1682">
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs" role="context" start="1911" end="1930">
fn get_network_txn_id(
&self,
request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<
Option<hyperswitch_domain_models::router_flow_types::ConnectorNetworkTxnId>,
errors::ConnectorError,
> {
let notif = get_webhook_object_from_body(request.body)
.change_context(errors::ConnectorError::WebhookBodyDecodingFailed)?;
let optional_network_txn_id =
notif
.additional_data
.network_tx_reference
.map(|network_txn_id| {
hyperswitch_domain_models::router_flow_types::ConnectorNetworkTxnId::new(
network_txn_id,
)
});
Ok(optional_network_txn_id)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen.rs" role="context" start="1850" end="1860">
fn get_webhook_resource_object(
&self,
request: &IncomingWebhookRequestDetails<'_>,
) -> CustomResult<Box<dyn masking::ErasedMaskSerialize>, errors::ConnectorError> {
let notif = get_webhook_object_from_body(request.body)
.change_context(errors::ConnectorError::WebhookEventTypeNotFound)?;
let response = adyen::AdyenWebhookResponse::from(notif);
Ok(Box::new(response))
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet.rs<|crate|> hyperswitch_connectors<|connector|> authorizedotnet anchor=get_error_response kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet.rs" role="context" start="975" end="1040">
fn get_error_response(
Response {
response,
status_code,
..
}: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
let response: authorizedotnet::AuthorizedotnetPaymentsResponse = response
.parse_struct("AuthorizedotnetPaymentsResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_error_response_body(&response));
router_env::logger::info!(connector_response=?response);
match response.transaction_response {
Some(authorizedotnet::TransactionResponse::AuthorizedotnetTransactionResponse(
payment_response,
)) => Ok(payment_response
.errors
.and_then(|errors| {
errors.into_iter().next().map(|error| ErrorResponse {
code: error.error_code,
message: error.error_text.to_owned(),
reason: Some(error.error_text),
status_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
})
.unwrap_or_else(|| ErrorResponse {
code: consts::NO_ERROR_CODE.to_string(), // authorizedotnet sends 200 in case of bad request so this are hard coded to NO_ERROR_CODE and NO_ERROR_MESSAGE
message: consts::NO_ERROR_MESSAGE.to_string(),
reason: None,
status_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})),
Some(authorizedotnet::TransactionResponse::AuthorizedotnetTransactionResponseError(_))
| None => {
let message = &response
.messages
.message
.first()
.ok_or(errors::ConnectorError::ResponseDeserializationFailed)?
.text;
Ok(ErrorResponse {
code: consts::NO_ERROR_CODE.to_string(),
message: message.to_string(),
reason: Some(message.to_string()),
status_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet.rs" role="context" start="974" end="974">
let payload: authorizedotnet::AuthorizedotnetWebhookObjectId = request
.body
.parse_struct("AuthorizedotnetWebhookObjectId")
.change_context(errors::ConnectorError::WebhookResourceObjectNotFound)?;
Ok(Box::new(
authorizedotnet::AuthorizedotnetSyncResponse::try_from(payload)?,
))
}
}
#[inline]
fn get_error_response(
Response {
response,
status_code,
..
}: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
let response: authorizedotnet::AuthorizedotnetPaymentsResponse = response
.parse_struct("AuthorizedotnetPaymentsResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_error_response_body(&response));
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet.rs" role="context" start="1043" end="1056">
fn get_flow_type(
&self,
_query_params: &str,
_json_payload: Option<serde_json::Value>,
action: PaymentAction,
) -> CustomResult<enums::CallConnectorAction, errors::ConnectorError> {
match action {
PaymentAction::PSync
| PaymentAction::CompleteAuthorize
| PaymentAction::PaymentAuthenticateCompleteAuthorize => {
Ok(enums::CallConnectorAction::Trigger)
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet.rs" role="context" start="959" end="971">
fn get_webhook_resource_object(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<Box<dyn masking::ErasedMaskSerialize>, errors::ConnectorError> {
let payload: authorizedotnet::AuthorizedotnetWebhookObjectId = request
.body
.parse_struct("AuthorizedotnetWebhookObjectId")
.change_context(errors::ConnectorError::WebhookResourceObjectNotFound)?;
Ok(Box::new(
authorizedotnet::AuthorizedotnetSyncResponse::try_from(payload)?,
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet.rs" role="context" start="946" end="957">
fn get_webhook_event_type(
&self,
request: &webhooks::IncomingWebhookRequestDetails<'_>,
) -> CustomResult<api_models::webhooks::IncomingWebhookEvent, errors::ConnectorError> {
let details: authorizedotnet::AuthorizedotnetWebhookEventType = request
.body
.parse_struct("AuthorizedotnetWebhookEventType")
.change_context(errors::ConnectorError::WebhookEventTypeNotFound)?;
Ok(api_models::webhooks::IncomingWebhookEvent::from(
details.event_type,
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet.rs" role="context" start="406" end="412">
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
get_error_response(res, event_builder)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet.rs" role="context" start="324" end="330">
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
get_error_response(res, event_builder)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/braintree/transformers.rs" role="context" start="1264" end="1266">
pub struct ErrorResponse {
errors: Vec<ErrorDetails>,
}
<file_sep path="hyperswitch/crates/analytics/docs/clickhouse/scripts/connector_events.sql" role="context" start="34" end="50">
_offset AS offset,
_raw_message AS raw,
_error AS error
FROM
connector_events_queue
WHERE
length(_error) > 0;
CREATE TABLE connector_events (
`merchant_id` LowCardinality(String),
`payment_id` Nullable(String),
`connector_name` LowCardinality(String),
`request_id` String,
`flow` LowCardinality(String),
`request` String,
`response` Nullable(String),
`masked_response` Nullable(String),
<file_sep path="hyperswitch/crates/api_models/src/errors/types.rs" role="context" start="42" end="52">
struct ErrorResponse<'a> {
#[serde(rename = "type")]
error_type: &'static str,
message: Cow<'a, str>,
code: String,
#[serde(flatten)]
extra: &'a Option<Extra>,
#[cfg(feature = "detailed_errors")]
#[serde(skip_serializing_if = "Option::is_none")]
stacktrace: Option<&'a serde_json::Value>,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/helcim/transformers.rs<|crate|> hyperswitch_connectors<|connector|> helcim anchor=from kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/helcim/transformers.rs" role="context" start="683" end="690">
fn from(item: RefundResponse) -> Self {
match item.transaction_type {
HelcimRefundTransactionType::Refund => match item.status {
HelcimPaymentStatus::Approved => Self::Success,
HelcimPaymentStatus::Declined => Self::Failure,
},
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/helcim/transformers.rs" role="context" start="710" end="720">
fn try_from(
item: RefundsResponseRouterData<RSync, RefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.transaction_id.to_string(),
refund_status: enums::RefundStatus::from(item.response),
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/helcim/transformers.rs" role="context" start="695" end="705">
fn try_from(
item: RefundsResponseRouterData<Execute, RefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.transaction_id.to_string(),
refund_status: enums::RefundStatus::from(item.response),
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/helcim/transformers.rs" role="context" start="646" end="665">
fn try_from(item: &HelcimRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
let original_transaction_id = item
.router_data
.request
.connector_transaction_id
.parse::<u64>()
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
let ip_address = item
.router_data
.request
.get_browser_info()?
.get_ip_address()?;
Ok(Self {
amount: item.amount,
original_transaction_id,
ip_address,
ecommerce: None,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/helcim/transformers.rs" role="context" start="605" end="629">
fn try_from(
item: ResponseRouterData<
F,
HelcimPaymentsResponse,
PaymentsCancelData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
item.response.transaction_id.to_string(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: item.response.invoice_number.clone(),
incremental_authorization_allowed: None,
charges: None,
}),
status: enums::AttemptStatus::from(item.response),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/helcim/transformers.rs" role="context" start="548" end="572">
fn try_from(
item: ResponseRouterData<
F,
HelcimPaymentsResponse,
PaymentsCaptureData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
item.response.transaction_id.to_string(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: item.response.invoice_number.clone(),
incremental_authorization_allowed: None,
charges: None,
}),
status: enums::AttemptStatus::from(item.response),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/helcim/transformers.rs" role="context" start="675" end="680">
pub struct RefundResponse {
status: HelcimPaymentStatus,
transaction_id: u64,
#[serde(rename = "type")]
transaction_type: HelcimRefundTransactionType,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/helcim/transformers.rs" role="context" start="670" end="672">
pub enum HelcimRefundTransactionType {
Refund,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bluesnap/transformers.rs" role="context" start="847" end="850">
pub struct Refund {
refund_transaction_id: String,
amount: StringMajorUnit,
}
<file_sep path="hyperswitch/v2_compatible_migrations/2024-08-28-081721_add_v2_columns/up.sql" role="context" start="59" end="70">
ALTER TABLE merchant_connector_account
ADD COLUMN IF NOT EXISTS feature_metadata JSONB;
ALTER TABLE payment_methods
ADD COLUMN IF NOT EXISTS locker_fingerprint_id VARCHAR(64),
ADD COLUMN IF NOT EXISTS payment_method_type_v2 VARCHAR(64),
ADD COLUMN IF NOT EXISTS payment_method_subtype VARCHAR(64);
ALTER TABLE refund
ADD COLUMN IF NOT EXISTS id VARCHAR(64),
ADD COLUMN IF NOT EXISTS merchant_reference_id VARCHAR(64),
ADD COLUMN IF NOT EXISTS connector_id VARCHAR(64);
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="169" end="217">
pub struct RefundResponse {
/// Unique Identifier for the refund
pub refund_id: String,
/// The payment id against which refund is initiated
#[schema(value_type = String)]
pub payment_id: common_utils::id_type::PaymentId,
/// The refund amount, which should be less than or equal to the total payment amount. Amount for the payment in lowest denomination of the currency. (i.e) in cents for USD denomination, in paisa for INR denomination etc
#[schema(value_type = i64 , minimum = 100, example = 6540)]
pub amount: MinorUnit,
/// The three-letter ISO currency code
pub currency: String,
/// The status for refund
pub status: RefundStatus,
/// An arbitrary string attached to the object. Often useful for displaying to users and your customer support executive
pub reason: Option<String>,
/// You can specify up to 50 keys, with key names up to 40 characters long and values up to 500 characters long. Metadata is useful for storing additional, structured information on an object
#[schema(value_type = Option<Object>)]
pub metadata: Option<pii::SecretSerdeValue>,
/// The error message
pub error_message: Option<String>,
/// The code for the error
pub error_code: Option<String>,
/// Error code unified across the connectors is received here if there was an error while calling connector
pub unified_code: Option<String>,
/// Error message unified across the connectors is received here if there was an error while calling connector
pub unified_message: Option<String>,
/// The timestamp at which refund is created
#[serde(with = "common_utils::custom_serde::iso8601::option")]
pub created_at: Option<PrimitiveDateTime>,
/// The timestamp at which refund is updated
#[serde(with = "common_utils::custom_serde::iso8601::option")]
pub updated_at: Option<PrimitiveDateTime>,
/// The connector used for the refund and the corresponding payment
#[schema(example = "stripe")]
pub connector: String,
/// The id of business profile for this refund
#[schema(value_type = Option<String>)]
pub profile_id: Option<common_utils::id_type::ProfileId>,
/// The merchant_connector_id of the processor through which this payment went through
#[schema(value_type = Option<String>)]
pub merchant_connector_id: Option<common_utils::id_type::MerchantConnectorAccountId>,
/// Charge specific fields for controlling the revert of funds from either platform or connected account
#[schema(value_type = Option<SplitRefund>,)]
pub split_refunds: Option<common_types::refunds::SplitRefund>,
/// Error code received from the issuer in case of failed refunds
pub issuer_error_code: Option<String>,
/// Error message received from the issuer in case of failed refunds
pub issuer_error_message: Option<String>,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu/transformers.rs<|crate|> hyperswitch_connectors<|connector|> fiuu anchor=from kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu/transformers.rs" role="context" start="1907" end="1913">
fn from(value: FiuuRefundsWebhookStatus) -> Self {
match value {
FiuuRefundsWebhookStatus::RefundFailure => Self::Failure,
FiuuRefundsWebhookStatus::RefundSuccess => Self::Success,
FiuuRefundsWebhookStatus::RefundPending => Self::Pending,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu/transformers.rs" role="context" start="1897" end="1903">
fn from(value: FiuuRefundsWebhookStatus) -> Self {
match value {
FiuuRefundsWebhookStatus::RefundSuccess => Self::RefundSuccess,
FiuuRefundsWebhookStatus::RefundFailure => Self::RefundFailure,
FiuuRefundsWebhookStatus::RefundPending => Self::EventNotSupported,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu/transformers.rs" role="context" start="1887" end="1893">
fn from(value: FiuuPaymentWebhookStatus) -> Self {
match value {
FiuuPaymentWebhookStatus::Success => Self::PaymentIntentSuccess,
FiuuPaymentWebhookStatus::Failure => Self::PaymentIntentFailure,
FiuuPaymentWebhookStatus::Pending => Self::PaymentIntentProcessing,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu/transformers.rs" role="context" start="1467" end="1522">
fn try_from(
item: PaymentsCaptureResponseRouterData<PaymentCaptureResponse>,
) -> Result<Self, Self::Error> {
let status_code = item.response.stat_code;
let status = match status_code.as_str() {
"00" => Ok(enums::AttemptStatus::Charged),
"22" => Ok(enums::AttemptStatus::Pending),
"11" | "12" | "13" | "15" | "16" | "17" | "18" | "19" | "20" | "21" | "23" | "24"
| "25" | "99" => Ok(enums::AttemptStatus::Failure),
other => Err(errors::ConnectorError::UnexpectedResponseError(
bytes::Bytes::from(other.to_owned()),
)),
}?;
let capture_message_status = capture_status_codes();
let error_response = if status == enums::AttemptStatus::Failure {
Some(ErrorResponse {
status_code: item.http_code,
code: status_code.to_owned(),
message: capture_message_status
.get(status_code.as_str())
.unwrap_or(&"NO_ERROR_MESSAGE")
.to_string(),
reason: Some(
capture_message_status
.get(status_code.as_str())
.unwrap_or(&"NO_ERROR_REASON")
.to_string(),
),
attempt_status: None,
connector_transaction_id: Some(item.response.tran_id.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
} else {
None
};
let payments_response_data = PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
item.response.tran_id.clone().to_string(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
};
Ok(Self {
status,
response: error_response.map_or_else(|| Ok(payments_response_data), Err),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu/transformers.rs" role="context" start="1403" end="1417">
fn try_from(sync_status: FiuuSyncStatus) -> Result<Self, Self::Error> {
match (sync_status.stat_code, sync_status.stat_name) {
(StatCode::Success, StatName::Captured | StatName::Settled) => Ok(Self::Charged), // For Success as StatCode we can only expect Captured,Settled and Authorized as StatName.
(StatCode::Success, StatName::Authorized) => Ok(Self::Authorized),
(StatCode::Pending, StatName::Pending) => Ok(Self::AuthenticationPending), // For Pending as StatCode we can only expect Pending and Unknow as StatName.
(StatCode::Pending, StatName::Unknown) => Ok(Self::Pending),
(StatCode::Failure, StatName::Cancelled) | (StatCode::Failure, StatName::ReqCancel) => {
Ok(Self::Voided)
}
(StatCode::Failure, _) => Ok(Self::Failure),
(other, _) => Err(errors::ConnectorError::UnexpectedResponseError(
bytes::Bytes::from(other.to_string()),
)),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu/transformers.rs" role="context" start="1831" end="1841">
pub enum FiuuRefundsWebhookStatus {
#[strum(serialize = "00")]
#[serde(rename = "00")]
RefundSuccess,
#[strum(serialize = "11")]
#[serde(rename = "11")]
RefundFailure,
#[strum(serialize = "22")]
#[serde(rename = "22")]
RefundPending,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/nexixpay/transformers.rs<|crate|> hyperswitch_connectors<|connector|> nexixpay anchor=from kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexixpay/transformers.rs" role="context" start="959" end="967">
fn from(item: NexixpayRefundResultStatus) -> Self {
match item {
NexixpayRefundResultStatus::Voided
| NexixpayRefundResultStatus::Refunded
| NexixpayRefundResultStatus::Executed => Self::Success,
NexixpayRefundResultStatus::Pending => Self::Pending,
NexixpayRefundResultStatus::Failed => Self::Failure,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexixpay/transformers.rs" role="context" start="987" end="997">
fn try_from(
item: RefundsResponseRouterData<RSync, NexixpayRSyncResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.operation_id,
refund_status: RefundStatus::from(item.response.operation_result),
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexixpay/transformers.rs" role="context" start="972" end="982">
fn try_from(
item: RefundsResponseRouterData<Execute, RefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.operation_id,
refund_status: RefundStatus::Pending, // Refund call do not return status in their response.
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexixpay/transformers.rs" role="context" start="950" end="955">
fn try_from(item: &NexixpayRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {
Ok(Self {
amount: item.amount.to_owned(),
currency: item.router_data.request.currency,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexixpay/transformers.rs" role="context" start="933" end="946">
fn nexixpay_threeds_link(
request: NexixpayRedirectionRequest,
) -> CustomResult<RedirectForm, errors::ConnectorError> {
let mut form_fields = HashMap::<String, String>::new();
form_fields.insert(String::from("ThreeDsRequest"), request.three_ds_request);
form_fields.insert(String::from("ReturnUrl"), request.return_url);
form_fields.insert(String::from("transactionId"), request.transaction_id);
Ok(RedirectForm::Form {
endpoint: request.three_d_s_auth_url,
method: Method::Post,
form_fields,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexixpay/transformers.rs" role="context" start="412" end="475">
fn try_from(
item: ResponseRouterData<
F,
NexixpayPreProcessingResponse,
PaymentsPreProcessingData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
let three_ds_data = item.response.three_d_s_auth_result;
let customer_details_encrypted: RedirectPayload = item
.data
.request
.redirect_response
.as_ref()
.and_then(|res| res.payload.to_owned())
.ok_or(errors::ConnectorError::MissingConnectorRedirectionPayload {
field_name: "request.redirect_response.payload",
})?
.expose()
.parse_value("RedirectPayload")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
let is_auto_capture = item.data.request.is_auto_capture()?;
let meta_data = to_connector_meta_from_secret(item.data.request.metadata.clone())?;
let connector_metadata = Some(update_nexi_meta_data(UpdateNexixpayConnectorMetaData {
three_d_s_auth_result: Some(three_ds_data),
three_d_s_auth_response: customer_details_encrypted.pa_res,
authorization_operation_id: None,
capture_operation_id: None,
cancel_operation_id: None,
psync_flow: None,
meta_data,
is_auto_capture,
})?);
let status = AttemptStatus::from(item.response.operation.operation_result.clone());
match status {
AttemptStatus::Failure => {
let response = Err(get_error_response(
item.response.operation.operation_result.clone(),
item.http_code,
));
Ok(Self {
response,
..item.data
})
}
_ => Ok(Self {
status,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
item.response.operation.order_id.clone(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata,
network_txn_id: None,
connector_response_reference_id: Some(item.response.operation.order_id),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
}),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/nexixpay/transformers.rs" role="context" start="703" end="709">
pub enum NexixpayRefundResultStatus {
Pending,
Voided,
Refunded,
Failed,
Executed,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs<|crate|> hyperswitch_connectors<|connector|> authorizedotnet anchor=from kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs" role="context" start="1829" end="1838">
fn from(event_type: AuthorizedotnetWebhookEvent) -> Self {
match event_type {
AuthorizedotnetWebhookEvent::AuthorizationCreated => Self::AuthorizedPendingCapture,
AuthorizedotnetWebhookEvent::CaptureCreated
| AuthorizedotnetWebhookEvent::AuthCapCreated => Self::CapturedPendingSettlement,
AuthorizedotnetWebhookEvent::PriorAuthCapture => Self::SettledSuccessfully,
AuthorizedotnetWebhookEvent::VoidCreated => Self::Voided,
AuthorizedotnetWebhookEvent::RefundCreated => Self::RefundSettledSuccessfully,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs" role="context" start="1853" end="1863">
fn try_from(item: AuthorizedotnetWebhookObjectId) -> Result<Self, Self::Error> {
Ok(Self {
transaction: Some(SyncTransactionResponse {
transaction_id: get_trans_id(&item)?,
transaction_status: SyncStatus::from(item.event_type),
}),
messages: ResponseMessages {
..Default::default()
},
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs" role="context" start="1841" end="1849">
pub fn get_trans_id(
details: &AuthorizedotnetWebhookObjectId,
) -> Result<String, errors::ConnectorError> {
details
.payload
.id
.clone()
.ok_or(errors::ConnectorError::WebhookReferenceIdNotFound)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs" role="context" start="1814" end="1824">
fn from(event_type: AuthorizedotnetIncomingWebhookEventType) -> Self {
match event_type {
AuthorizedotnetIncomingWebhookEventType::AuthorizationCreated
| AuthorizedotnetIncomingWebhookEventType::PriorAuthCapture
| AuthorizedotnetIncomingWebhookEventType::AuthCapCreated
| AuthorizedotnetIncomingWebhookEventType::CaptureCreated
| AuthorizedotnetIncomingWebhookEventType::VoidCreated => Self::PaymentIntentSuccess,
AuthorizedotnetIncomingWebhookEventType::RefundCreated => Self::RefundSuccess,
AuthorizedotnetIncomingWebhookEventType::Unknown => Self::EventNotSupported,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs" role="context" start="1739" end="1758">
fn get_err_response(
status_code: u16,
message: ResponseMessages,
) -> Result<ErrorResponse, errors::ConnectorError> {
let response_message = message
.message
.first()
.ok_or(errors::ConnectorError::ResponseDeserializationFailed)?;
Ok(ErrorResponse {
code: response_message.code.clone(),
message: response_message.text.clone(),
reason: Some(response_message.text.clone()),
status_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs" role="context" start="1305" end="1365">
fn try_from(
item: ResponseRouterData<F, AuthorizedotnetVoidResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
match &item.response.transaction_response {
Some(transaction_response) => {
let status = enums::AttemptStatus::from(transaction_response.response_code.clone());
let error = transaction_response.errors.as_ref().and_then(|errors| {
errors.iter().next().map(|error| ErrorResponse {
code: error.error_code.clone(),
message: error.error_text.clone(),
reason: Some(error.error_text.clone()),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(transaction_response.transaction_id.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
});
let metadata = transaction_response
.account_number
.as_ref()
.map(|acc_no| {
construct_refund_payment_details(acc_no.clone().expose()).encode_to_value()
})
.transpose()
.change_context(errors::ConnectorError::MissingRequiredField {
field_name: "connector_metadata",
})?;
Ok(Self {
status,
response: match error {
Some(err) => Err(err),
None => Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
transaction_response.transaction_id.clone(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: metadata,
network_txn_id: transaction_response
.network_trans_id
.clone()
.map(|network_trans_id| network_trans_id.expose()),
connector_response_reference_id: Some(
transaction_response.transaction_id.clone(),
),
incremental_authorization_allowed: None,
charges: None,
}),
},
..item.data
})
}
None => Ok(Self {
status: enums::AttemptStatus::Failure,
response: Err(get_err_response(item.http_code, item.response.messages)?),
..item.data
}),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs" role="context" start="1205" end="1298">
fn foreign_try_from(
(item, is_auto_capture): (
ResponseRouterData<F, AuthorizedotnetPaymentsResponse, T, PaymentsResponseData>,
bool,
),
) -> Result<Self, Self::Error> {
match &item.response.transaction_response {
Some(TransactionResponse::AuthorizedotnetTransactionResponse(transaction_response)) => {
let status = get_payment_status((
transaction_response.response_code.clone(),
is_auto_capture,
));
let error = transaction_response.errors.as_ref().and_then(|errors| {
errors.iter().next().map(|error| ErrorResponse {
code: error.error_code.clone(),
message: error.error_text.clone(),
reason: Some(error.error_text.clone()),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(transaction_response.transaction_id.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
});
let metadata = transaction_response
.account_number
.as_ref()
.map(|acc_no| {
construct_refund_payment_details(acc_no.clone().expose()).encode_to_value()
})
.transpose()
.change_context(errors::ConnectorError::MissingRequiredField {
field_name: "connector_metadata",
})?;
let url = transaction_response
.secure_acceptance
.as_ref()
.and_then(|x| x.secure_acceptance_url.to_owned());
let redirection_data = url.map(|url| RedirectForm::from((url, Method::Get)));
let mandate_reference = item.response.profile_response.map(|profile_response| {
let payment_profile_id = profile_response
.customer_payment_profile_id_list
.and_then(|customer_payment_profile_id_list| {
customer_payment_profile_id_list.first().cloned()
});
MandateReference {
connector_mandate_id: profile_response.customer_profile_id.and_then(
|customer_profile_id| {
payment_profile_id.map(|payment_profile_id| {
format!("{customer_profile_id}-{payment_profile_id}")
})
},
),
payment_method_id: None,
mandate_metadata: None,
connector_mandate_request_reference_id: None,
}
});
Ok(Self {
status,
response: match error {
Some(err) => Err(err),
None => Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
transaction_response.transaction_id.clone(),
),
redirection_data: Box::new(redirection_data),
mandate_reference: Box::new(mandate_reference),
connector_metadata: metadata,
network_txn_id: transaction_response
.network_trans_id
.clone()
.map(|network_trans_id| network_trans_id.expose()),
connector_response_reference_id: Some(
transaction_response.transaction_id.clone(),
),
incremental_authorization_allowed: None,
charges: None,
}),
},
..item.data
})
}
Some(TransactionResponse::AuthorizedotnetTransactionResponseError(_)) | None => {
Ok(Self {
status: enums::AttemptStatus::Failure,
response: Err(get_err_response(item.http_code, item.response.messages)?),
..item.data
})
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs" role="context" start="1780" end="1793">
pub enum AuthorizedotnetWebhookEvent {
#[serde(rename = "net.authorize.payment.authorization.created")]
AuthorizationCreated,
#[serde(rename = "net.authorize.payment.priorAuthCapture.created")]
PriorAuthCapture,
#[serde(rename = "net.authorize.payment.authcapture.created")]
AuthCapCreated,
#[serde(rename = "net.authorize.payment.capture.created")]
CaptureCreated,
#[serde(rename = "net.authorize.payment.void.created")]
VoidCreated,
#[serde(rename = "net.authorize.payment.refund.created")]
RefundCreated,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/fiserv/transformers.rs<|crate|> hyperswitch_connectors<|connector|> fiserv anchor=try_from kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiserv/transformers.rs" role="context" start="624" end="645">
fn try_from(
item: RefundsResponseRouterData<RSync, FiservSyncResponse>,
) -> Result<Self, Self::Error> {
let gateway_resp = item
.response
.sync_responses
.first()
.ok_or(errors::ConnectorError::ResponseHandlingFailed)?;
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: gateway_resp
.gateway_response
.transaction_processing_details
.transaction_id
.clone(),
refund_status: enums::RefundStatus::from(
gateway_resp.gateway_response.transaction_state.clone(),
),
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiserv/transformers.rs" role="context" start="623" end="623">
use common_enums::enums;
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, RouterData},
router_flow_types::refunds::{Execute, RSync},
router_request_types::ResponseId,
router_response_types::{PaymentsResponseData, RefundsResponseData},
types,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, CardData as CardDataUtil, PaymentsCancelRequestData, PaymentsSyncRequestData,
RouterData as _,
},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiserv/transformers.rs" role="context" start="601" end="617">
fn try_from(
item: RefundsResponseRouterData<Execute, RefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item
.response
.gateway_response
.transaction_processing_details
.transaction_id,
refund_status: enums::RefundStatus::from(
item.response.gateway_response.transaction_state,
),
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiserv/transformers.rs" role="context" start="557" end="588">
fn try_from(
item: &FiservRouterData<&types::RefundsRouterData<F>>,
) -> Result<Self, Self::Error> {
let auth: FiservAuthType = FiservAuthType::try_from(&item.router_data.connector_auth_type)?;
let metadata = item
.router_data
.connector_meta_data
.clone()
.ok_or(errors::ConnectorError::RequestEncodingFailed)?;
let session: FiservSessionObject = metadata
.parse_value("FiservSessionObject")
.change_context(errors::ConnectorError::InvalidConnectorConfig {
config: "Merchant connector account metadata",
})?;
Ok(Self {
amount: Amount {
total: item.amount,
currency: item.router_data.request.currency.to_string(),
},
merchant_details: MerchantDetails {
merchant_id: auth.merchant_account,
terminal_id: Some(session.terminal_id),
},
reference_transaction_details: ReferenceTransactionDetails {
reference_transaction_id: item
.router_data
.request
.connector_transaction_id
.to_string(),
},
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiserv/transformers.rs" role="context" start="529" end="544">
fn try_from(item: &types::RefundSyncRouterData) -> Result<Self, Self::Error> {
let auth: FiservAuthType = FiservAuthType::try_from(&item.connector_auth_type)?;
Ok(Self {
merchant_details: MerchantDetails {
merchant_id: auth.merchant_account,
terminal_id: None,
},
reference_transaction_details: ReferenceTransactionDetails {
reference_transaction_id: item
.request
.connector_refund_id
.clone()
.ok_or(errors::ConnectorError::RequestEncodingFailed)?,
},
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiserv/transformers.rs" role="context" start="462" end="498">
fn try_from(
item: &FiservRouterData<&types::PaymentsCaptureRouterData>,
) -> Result<Self, Self::Error> {
let auth: FiservAuthType = FiservAuthType::try_from(&item.router_data.connector_auth_type)?;
let metadata = item
.router_data
.connector_meta_data
.clone()
.ok_or(errors::ConnectorError::RequestEncodingFailed)?;
let session: FiservSessionObject = metadata
.parse_value("FiservSessionObject")
.change_context(errors::ConnectorError::InvalidConnectorConfig {
config: "Merchant connector account metadata",
})?;
Ok(Self {
amount: Amount {
total: item.amount,
currency: item.router_data.request.currency.to_string(),
},
transaction_details: TransactionDetails {
capture_flag: Some(true),
reversal_reason_code: None,
merchant_transaction_id: item.router_data.connector_request_reference_id.clone(),
},
merchant_details: MerchantDetails {
merchant_id: auth.merchant_account,
terminal_id: Some(session.terminal_id),
},
reference_transaction_details: ReferenceTransactionDetails {
reference_transaction_id: item
.router_data
.request
.connector_transaction_id
.to_string(),
},
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiserv/transformers.rs" role="context" start="317" end="325">
fn from(item: FiservPaymentStatus) -> Self {
match item {
FiservPaymentStatus::Succeeded
| FiservPaymentStatus::Authorized
| FiservPaymentStatus::Captured => Self::Success,
FiservPaymentStatus::Declined | FiservPaymentStatus::Failed => Self::Failure,
FiservPaymentStatus::Voided | FiservPaymentStatus::Processing => Self::Pending,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiserv/transformers.rs" role="context" start="31" end="31">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiserv/transformers.rs" role="context" start="337" end="339">
pub struct FiservSyncResponse {
sync_responses: Vec<FiservPaymentsResponse>,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/chargebee/transformers.rs" role="context" start="193" end="198">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Processing,
}
<file_sep path="hyperswitch/crates/api_models/src/payment_methods.rs" role="context" start="2478" end="2478">
type Error = error_stack::Report<errors::ValidationError>;
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/bamboraapac/transformers.rs<|crate|> hyperswitch_connectors<|connector|> bamboraapac anchor=try_from kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bamboraapac/transformers.rs" role="context" start="1009" end="1035">
fn try_from(
item: ResponseRouterData<F, BamboraapacSyncResponse, RefundsData, RefundsResponseData>,
) -> Result<Self, Self::Error> {
let response_code = item
.response
.body
.query_transaction_response
.query_transaction_result
.query_response
.response
.response_code;
let connector_refund_id = item
.response
.body
.query_transaction_response
.query_transaction_result
.query_response
.response
.receipt;
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: connector_refund_id.to_owned(),
refund_status: get_status(response_code),
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bamboraapac/transformers.rs" role="context" start="1008" end="1008">
use hyperswitch_domain_models::{
payment_method_data::PaymentMethodData,
router_data::{ConnectorAuthType, ErrorResponse, RouterData},
router_request_types::{
PaymentsAuthorizeData, PaymentsCaptureData, PaymentsSyncData, RefundsData, ResponseId,
SetupMandateRequestData,
},
router_response_types::{MandateReference, PaymentsResponseData, RefundsResponseData},
types,
};
use crate::{
types::ResponseRouterData,
utils::{self, CardData as _, PaymentsAuthorizeRequestData, RouterData as _},
};
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bamboraapac/transformers.rs" role="context" start="966" end="1003">
pub fn get_refund_sync_body(req: &types::RefundSyncRouterData) -> Result<Vec<u8>, Error> {
let auth_details = BamboraapacAuthType::try_from(&req.connector_auth_type)?;
let body = format!(
r#"
<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/"
xmlns:dts="http://www.ippayments.com.au/interface/api/dts">
<soapenv:Header/>
<soapenv:Body>
<dts:QueryTransaction>
<dts:queryXML>
<![CDATA[
<QueryTransaction>
<Criteria>
<AccountNumber>{}</AccountNumber>
<TrnStartTimestamp>2024-06-23 00:00:00</TrnStartTimestamp>
<TrnEndTimestamp>2099-12-31 23:59:59</TrnEndTimestamp>
<CustRef>{}</CustRef>
</Criteria>
<Security>
<UserName>{}</UserName>
<Password>{}</Password>
</Security>
</QueryTransaction>
]]>
</dts:queryXML>
</dts:QueryTransaction>
</soapenv:Body>
</soapenv:Envelope>
"#,
auth_details.account_number.peek(),
req.request.refund_id,
auth_details.username.peek(),
auth_details.password.peek(),
);
Ok(body.as_bytes().to_vec())
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bamboraapac/transformers.rs" role="context" start="884" end="963">
fn try_from(
item: ResponseRouterData<
F,
BamboraapacSyncResponse,
PaymentsSyncData,
PaymentsResponseData,
>,
) -> Result<Self, Self::Error> {
let response_code = item
.response
.body
.query_transaction_response
.query_transaction_result
.query_response
.response
.response_code;
let connector_transaction_id = item
.response
.body
.query_transaction_response
.query_transaction_result
.query_response
.response
.receipt;
// transaction approved
if response_code == 0 {
Ok(Self {
status: get_attempt_status(response_code, item.data.request.capture_method),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
connector_transaction_id.to_owned(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(connector_transaction_id),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
// transaction failed
else {
let code = item
.response
.body
.query_transaction_response
.query_transaction_result
.query_response
.response
.declined_code
.unwrap_or(NO_ERROR_CODE.to_string());
let declined_message = item
.response
.body
.query_transaction_response
.query_transaction_result
.query_response
.response
.declined_message
.unwrap_or(NO_ERROR_MESSAGE.to_string());
Ok(Self {
status: get_attempt_status(response_code, item.data.request.capture_method),
response: Err(ErrorResponse {
status_code: item.http_code,
code,
message: declined_message.to_owned(),
reason: Some(declined_message),
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
}),
..item.data
})
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bamboraapac/transformers.rs" role="context" start="518" end="552">
pub fn get_capture_body(
req: &BamboraapacRouterData<&types::PaymentsCaptureRouterData>,
) -> Result<Vec<u8>, Error> {
let receipt = req.router_data.request.connector_transaction_id.to_owned();
let auth_details = BamboraapacAuthType::try_from(&req.router_data.connector_auth_type)?;
let body = format!(
r#"
<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/"
xmlns:dts="http://www.ippayments.com.au/interface/api/dts">
<soapenv:Body>
<dts:SubmitSingleCapture>
<dts:trnXML>
<![CDATA[
<Capture>
<Receipt>{}</Receipt>
<Amount>{}</Amount>
<Security>
<UserName>{}</UserName>
<Password>{}</Password>
</Security>
</Capture>
]]>
</dts:trnXML>
</dts:SubmitSingleCapture>
</soapenv:Body>
</soapenv:Envelope>
"#,
receipt,
req.amount,
auth_details.username.peek(),
auth_details.password.peek(),
);
Ok(body.as_bytes().to_vec())
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bamboraapac/transformers.rs" role="context" start="796" end="837">
pub fn get_payment_sync_body(req: &types::PaymentsSyncRouterData) -> Result<Vec<u8>, Error> {
let auth_details = BamboraapacAuthType::try_from(&req.connector_auth_type)?;
let connector_transaction_id = req
.request
.connector_transaction_id
.get_connector_transaction_id()
.change_context(errors::ConnectorError::MissingConnectorTransactionID)?;
let body = format!(
r#"
<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/"
xmlns:dts="http://www.ippayments.com.au/interface/api/dts">
<soapenv:Header/>
<soapenv:Body>
<dts:QueryTransaction>
<dts:queryXML>
<![CDATA[
<QueryTransaction>
<Criteria>
<AccountNumber>{}</AccountNumber>
<TrnStartTimestamp>2024-06-23 00:00:00</TrnStartTimestamp>
<TrnEndTimestamp>2099-12-31 23:59:59</TrnEndTimestamp>
<Receipt>{}</Receipt>
</Criteria>
<Security>
<UserName>{}</UserName>
<Password>{}</Password>
</Security>
</QueryTransaction>
]]>
</dts:queryXML>
</dts:QueryTransaction>
</soapenv:Body>
</soapenv:Envelope>
"#,
auth_details.account_number.peek(),
connector_transaction_id,
auth_details.username.peek(),
auth_details.password.peek(),
);
Ok(body.as_bytes().to_vec())
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bamboraapac/transformers.rs" role="context" start="756" end="762">
fn get_status(item: u8) -> enums::RefundStatus {
match item {
0 => enums::RefundStatus::Success,
1 => enums::RefundStatus::Failure,
_ => enums::RefundStatus::Pending,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bamboraapac/transformers.rs" role="context" start="26" end="26">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bamboraapac/transformers.rs" role="context" start="842" end="844">
pub struct BamboraapacSyncResponse {
body: SyncBodyResponse,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/inespay/transformers.rs" role="context" start="332" end="336">
pub struct RefundsData {
status: String,
status_desc: String,
refund_id: String,
}
<file_sep path="hyperswitch/crates/api_models/src/payment_methods.rs" role="context" start="2478" end="2478">
type Error = error_stack::Report<errors::ValidationError>;
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/paybox/transformers.rs<|crate|> hyperswitch_connectors<|connector|> paybox anchor=get_paybox_request_number kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paybox/transformers.rs" role="context" start="534" end="546">
fn get_paybox_request_number() -> Result<String, Error> {
let time_stamp = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.ok()
.ok_or(errors::ConnectorError::RequestEncodingFailed)?
.as_millis()
.to_string();
// unix time (in milliseconds) has 13 digits.if we consider 8 digits(the number digits to make day deterministic) there is no collision in the paybox_request_number as it will reset the paybox_request_number for each day and paybox accepting maximum length is 10 so we gonna take 9 (13-9)
let request_number = time_stamp
.get(4..)
.ok_or(errors::ConnectorError::ParsingFailed)?;
Ok(request_number.to_string())
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paybox/transformers.rs" role="context" start="533" end="533">
use common_utils::{
date_time::DateFormat, errors::CustomResult, ext_traits::ValueExt, types::MinorUnit,
};
use crate::{
types::{RefundsResponseRouterData, ResponseRouterData},
utils::{
self, AddressDetailsData, CardData as _, PaymentsAuthorizeRequestData,
PaymentsCompleteAuthorizeRequestData, RouterData as _,
},
};
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paybox/transformers.rs" role="context" start="605" end="610">
pub fn parse_url_encoded_to_struct<T: DeserializeOwned>(
query_bytes: Bytes,
) -> CustomResult<T, errors::ConnectorError> {
let (cow, _, _) = encoding_rs::ISO_8859_15.decode(&query_bytes);
serde_qs::from_str::<T>(cow.as_ref()).change_context(errors::ConnectorError::ParsingFailed)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paybox/transformers.rs" role="context" start="558" end="575">
fn try_from(auth_type: &ConnectorAuthType) -> Result<Self, Self::Error> {
if let ConnectorAuthType::MultiAuthKey {
api_key,
key1,
api_secret,
key2,
} = auth_type
{
Ok(Self {
site: api_key.to_owned(),
rang: key1.to_owned(),
cle: api_secret.to_owned(),
merchant_id: key2.to_owned(),
})
} else {
Err(errors::ConnectorError::FailedToObtainAuthType)?
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paybox/transformers.rs" role="context" start="510" end="533">
fn get_transaction_type(
capture_method: Option<enums::CaptureMethod>,
is_mandate_request: bool,
) -> Result<String, Error> {
match (capture_method, is_mandate_request) {
(Some(enums::CaptureMethod::Automatic), false)
| (None, false)
| (Some(enums::CaptureMethod::SequentialAutomatic), false) => {
Ok(AUTH_AND_CAPTURE_REQUEST.to_string())
}
(Some(enums::CaptureMethod::Automatic), true) | (None, true) => {
Err(errors::ConnectorError::NotSupported {
message: "Automatic Capture in CIT payments".to_string(),
connector: "Paybox",
})?
}
(Some(enums::CaptureMethod::Manual), false) => Ok(AUTH_REQUEST.to_string()),
(Some(enums::CaptureMethod::Manual), true)
| (Some(enums::CaptureMethod::SequentialAutomatic), true) => {
Ok(MANDATE_REQUEST.to_string())
}
_ => Err(errors::ConnectorError::CaptureMethodNotSupported)?,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paybox/transformers.rs" role="context" start="487" end="508">
fn extract_card_mandate_info(
additional_payment_method_data: Option<AdditionalPaymentData>,
) -> Result<CardMandateInfo, Error> {
match additional_payment_method_data {
Some(AdditionalPaymentData::Card(card_data)) => Ok(CardMandateInfo {
card_exp_month: card_data.card_exp_month.clone().ok_or_else(|| {
errors::ConnectorError::MissingRequiredField {
field_name: "card_exp_month",
}
})?,
card_exp_year: card_data.card_exp_year.clone().ok_or_else(|| {
errors::ConnectorError::MissingRequiredField {
field_name: "card_exp_year",
}
})?,
}),
_ => Err(errors::ConnectorError::MissingRequiredFields {
field_names: vec!["card_exp_month", "card_exp_year"],
}
.into()),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paybox/transformers.rs" role="context" start="386" end="484">
fn try_from(
item: &PayboxRouterData<&types::PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
match item.router_data.request.payment_method_data.clone() {
PaymentMethodData::Card(req_card) => {
let auth_data: PayboxAuthType =
PayboxAuthType::try_from(&item.router_data.connector_auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
let transaction_type = get_transaction_type(
item.router_data.request.capture_method,
item.router_data.request.is_mandate_payment(),
)?;
let currency =
enums::Currency::iso_4217(item.router_data.request.currency).to_string();
let expiration_date =
req_card.get_card_expiry_month_year_2_digit_with_delimiter("".to_owned())?;
let format_time = common_utils::date_time::format_date(
common_utils::date_time::now(),
DateFormat::DDMMYYYYHHmmss,
)
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
if item.router_data.is_three_ds() {
let address = item.router_data.get_billing_address()?;
Ok(Self::CardThreeDs(ThreeDSPaymentsRequest {
id_merchant: auth_data.merchant_id,
id_session: item.router_data.connector_request_reference_id.clone(),
amount: item.amount,
currency,
cc_number: req_card.card_number,
cc_exp_date: expiration_date,
cvv_code: req_card.card_cvc,
url_retour: item.router_data.request.get_complete_authorize_url()?,
url_http_direct: item.router_data.request.get_complete_authorize_url()?,
email_porteur: item.router_data.request.get_email()?,
first_name: address.get_first_name()?.clone(),
last_name: address.get_last_name()?.clone(),
address1: address.get_line1()?.clone(),
zip_code: address.get_zip()?.clone(),
city: address.get_city()?.clone(),
country_code: format!(
"{:03}",
common_enums::Country::from_alpha2(*address.get_country()?)
.to_numeric()
),
total_quantity: 1,
}))
} else {
Ok(Self::Card(PaymentsRequest {
date: format_time.clone(),
transaction_type,
paybox_request_number: get_paybox_request_number()?,
amount: item.amount,
description_reference: item
.router_data
.connector_request_reference_id
.clone(),
version: VERSION_PAYBOX.to_string(),
currency,
card_number: req_card.card_number,
expiration_date,
cvv: req_card.card_cvc,
activity: PAY_ORIGIN_INTERNET.to_string(),
site: auth_data.site,
rank: auth_data.rang,
key: auth_data.cle,
three_ds_data: None,
customer_id: match item.router_data.request.is_mandate_payment() {
true => {
let reference_id = item
.router_data
.connector_mandate_request_reference_id
.clone()
.ok_or_else(|| {
errors::ConnectorError::MissingRequiredField {
field_name: "connector_mandate_request_reference_id",
}
})?;
Some(Secret::new(reference_id))
}
false => None,
},
}))
}
}
PaymentMethodData::MandatePayment => {
let mandate_data = extract_card_mandate_info(
item.router_data
.request
.additional_payment_method_data
.clone(),
)?;
Ok(Self::Mandate(MandatePaymentRequest::try_from((
item,
mandate_data,
))?))
}
_ => Err(errors::ConnectorError::NotImplemented("Payment methods".to_string()).into()),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paybox/transformers.rs" role="context" start="1198" end="1245">
fn try_from(
(item, card_mandate_info): (
&PayboxRouterData<&types::PaymentsAuthorizeRouterData>,
CardMandateInfo,
),
) -> Result<Self, Self::Error> {
let auth_data: PayboxAuthType =
PayboxAuthType::try_from(&item.router_data.connector_auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
let transaction_type = match item.router_data.request.capture_method {
Some(enums::CaptureMethod::Automatic)
| None
| Some(enums::CaptureMethod::SequentialAutomatic) => {
Ok(MANDATE_AUTH_AND_CAPTURE_ONLY.to_string())
}
Some(enums::CaptureMethod::Manual) => Ok(MANDATE_AUTH_ONLY.to_string()),
_ => Err(errors::ConnectorError::CaptureMethodNotSupported),
}?;
let currency = enums::Currency::iso_4217(item.router_data.request.currency).to_string();
let format_time = common_utils::date_time::format_date(
common_utils::date_time::now(),
DateFormat::DDMMYYYYHHmmss,
)
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
Ok(Self {
date: format_time.clone(),
transaction_type,
paybox_request_number: get_paybox_request_number()?,
amount: item.router_data.request.minor_amount,
description_reference: item.router_data.connector_request_reference_id.clone(),
version: VERSION_PAYBOX.to_string(),
currency,
activity: RECURRING_ORIGIN.to_string(),
site: auth_data.site,
rank: auth_data.rang,
key: auth_data.cle,
customer_id: Secret::new(
item.router_data
.request
.get_connector_mandate_request_reference_id()?,
),
carrier_id: Secret::new(item.router_data.request.get_connector_mandate_id()?),
cc_exp_date: get_card_expiry_month_year_2_digit(
card_mandate_info.card_exp_month.clone(),
card_mandate_info.card_exp_year.clone(),
)?,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paybox/transformers.rs" role="context" start="60" end="60">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/api_models/src/payment_methods.rs" role="context" start="2478" end="2478">
type Error = error_stack::Report<errors::ValidationError>;
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/razorpay/transformers.rs<|crate|> hyperswitch_connectors<|connector|> razorpay anchor=try_from kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/razorpay/transformers.rs" role="context" start="1398" end="1418">
fn try_from(webhook_payload: RazorpayWebhookPayload) -> Result<Self, Self::Error> {
webhook_payload
.refund
.map_or(
match webhook_payload.payment.entity.status {
RazorpayPaymentStatus::Created => Some(Self::PaymentIntentProcessing),
RazorpayPaymentStatus::Authorized => {
Some(Self::PaymentIntentAuthorizationSuccess)
}
RazorpayPaymentStatus::Captured => Some(Self::PaymentIntentSuccess),
RazorpayPaymentStatus::Failed => Some(Self::PaymentIntentFailure),
RazorpayPaymentStatus::Refunded => None,
},
|refund_data| match refund_data.entity.status {
RazorpayRefundStatus::Pending => None,
RazorpayRefundStatus::Processed => Some(Self::RefundSuccess),
RazorpayRefundStatus::Failed => Some(Self::RefundFailure),
},
)
.ok_or(errors::ConnectorError::WebhookEventTypeNotFound)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/razorpay/transformers.rs" role="context" start="1290" end="1305">
fn try_from(
item: RefundsResponseRouterData<RSync, RefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item
.data
.request
.connector_refund_id
.clone()
.ok_or(errors::ConnectorError::MissingConnectorRefundID)?,
refund_status: enums::RefundStatus::from(item.response.refund.status),
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/razorpay/transformers.rs" role="context" start="1248" end="1285">
fn try_from(
item: RefundsResponseRouterData<Execute, RefundResponse>,
) -> Result<Self, Self::Error> {
let epg_txn_id = item.response.refund.epg_txn_id.clone();
let refund_status = enums::RefundStatus::from(item.response.refund.status);
let response = match epg_txn_id {
Some(epg_txn_id) => Ok(RefundsResponseData {
connector_refund_id: epg_txn_id,
refund_status,
}),
None => Err(hyperswitch_domain_models::router_data::ErrorResponse {
code: item
.response
.refund
.error_message
.clone()
.unwrap_or(NO_ERROR_CODE.to_string()),
message: item
.response
.refund
.response_code
.clone()
.unwrap_or(NO_ERROR_MESSAGE.to_string()),
reason: item.response.refund.response_code.clone(),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(item.response.refund.unique_request_id.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
}),
};
Ok(Self {
response,
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/razorpay/transformers.rs" role="context" start="378" end="439">
fn try_from(
(item, data): (
&RazorpayRouterData<&types::PaymentsAuthorizeRouterData>,
&Connectors,
),
) -> Result<Self, Self::Error> {
let request = &item.router_data.request;
let txn_card_info = match request.payment_method_data.clone() {
PaymentMethodData::Upi(upi_type) => match upi_type {
UpiData::UpiCollect(upi_data) => TxnCardInfo::try_from((item, upi_data)),
UpiData::UpiIntent(_) => Err(errors::ConnectorError::NotImplemented(
"Payment methods".to_string(),
)
.into()),
},
PaymentMethodData::Card(_)
| PaymentMethodData::CardRedirect(_)
| PaymentMethodData::Wallet(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {
Err(errors::ConnectorError::NotImplemented("Payment methods".to_string()).into())
}
}?;
let merchant_data = JuspayAuthData::try_from(data)?;
let second_factor = SecondFactor::try_from(item)?;
let merchant_account = MerchantAccount::try_from((item, data))?;
let order_reference = OrderReference::try_from((item, data))?;
let txn_detail = TxnDetail::try_from((item, data))?;
let merchant_gateway_account = MerchantGatewayAccount::try_from((item, data))?;
let gateway = Gateway::Razorpay;
let transaction_create_req = TransactionCreateReq {
merchant_id: merchant_data.merchant_id,
};
let is_mesh_enabled = false;
let order_metadata_v2 = OrderMetadataV2::try_from(item)?;
Ok(Self {
second_factor,
merchant_account,
order_reference,
txn_detail,
txn_card_info,
merchant_gateway_account,
gateway,
transaction_create_req,
is_mesh_enabled,
order_metadata_v2,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/razorpay/transformers.rs" role="context" start="868" end="970">
fn try_from(
(item, data): (
RazorpayRouterData<&types::PaymentsSyncRouterData>,
&Connectors,
),
) -> Result<Self, Self::Error> {
let ref_id = generate_12_digit_number();
let auth = RazorpayAuthType::try_from(&item.router_data.connector_auth_type)?;
let merchant_data = JuspayAuthData::try_from(data)?;
let connector_transaction_id = item
.router_data
.request
.connector_transaction_id
.get_connector_transaction_id()
.change_context(errors::ConnectorError::MissingConnectorTransactionID)?;
let connector_request_reference_id = &item.router_data.connector_request_reference_id;
let second_factor = SecondFactor {
txn_id: connector_request_reference_id.clone(),
id: ref_id.to_string(),
status: SecondFactorStatus::Pending,
version: VERSION,
sf_type: SecondFactorType::Vbv,
date_created: Some(common_utils::date_time::now()),
last_updated: Some(common_utils::date_time::now()),
epg_txn_id: Some(connector_transaction_id.clone()),
..Default::default()
};
let order_reference = OrderReference {
id: ref_id.to_string(),
amount: item.amount,
currency: item.router_data.request.currency.to_string(),
status: OrderStatus::PendingAuthentication,
merchant_id: merchant_data.merchant_id.clone(),
order_id: connector_request_reference_id.clone(),
version: VERSION,
order_type: OrderType::OrderPayment,
order_uuid: uuid::Uuid::new_v4().to_string(),
date_created: Some(common_utils::date_time::now()),
last_modified: Some(common_utils::date_time::now()),
..Default::default()
};
let txn_mode: TxnMode = match item.router_data.test_mode {
Some(true) | None => TxnMode::Test,
Some(false) => TxnMode::Prod,
};
let txn_detail = TxnDetail {
order_id: connector_request_reference_id.clone(),
express_checkout: false,
txn_mode,
merchant_id: merchant_data.merchant_id.clone(),
status: TxnStatus::from(item.router_data.status),
net_amount: item.amount,
txn_id: connector_request_reference_id.clone(),
txn_amount: item.amount,
emi_tenure: 0,
txn_uuid: uuid::Uuid::new_v4().to_string(),
id: ref_id.to_string(),
merchant_gateway_account_id: 11476,
txn_type: TxnType::AuthAndSettle,
redirect: true,
version: VERSION,
add_to_locker: false,
currency: item.router_data.request.currency.to_string(),
is_emi: false,
gateway: Gateway::Razorpay,
date_created: Some(common_utils::date_time::now()),
last_modified: Some(common_utils::date_time::now()),
..Default::default()
};
let account_details = AccountDetails {
razorpay_id: auth.razorpay_id.clone(),
razorpay_secret: auth.razorpay_secret,
};
let merchant_gateway_account = MerchantGatewayAccount {
gateway: Gateway::Razorpay,
disabled: false,
id: ref_id,
account_details: serde_json::to_string(&account_details)
.change_context(errors::ConnectorError::ParsingFailed)?,
test_mode: false,
merchant_id: merchant_data.merchant_id,
..Default::default()
};
let gateway_txn_data = GatewayTxnData {
id: ref_id.to_string(),
version: VERSION,
gateway_data: "".to_string(),
gateway_status: "S".to_string(),
match_status: "S".to_string(),
txn_detail_id: ref_id.to_string(),
date_created: Some(common_utils::date_time::now()),
last_updated: Some(common_utils::date_time::now()),
};
Ok(Self {
second_factor,
merchant_gateway_account,
order_reference,
txn_detail,
gateway_txn_data,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/razorpay/transformers.rs" role="context" start="35" end="35">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/razorpay/transformers.rs" role="context" start="1390" end="1394">
pub enum RazorpayRefundStatus {
Pending,
Processed,
Failed,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/razorpay/transformers.rs" role="context" start="1380" end="1386">
pub enum RazorpayPaymentStatus {
Created,
Authorized,
Captured,
Failed,
Refunded,
}
<file_sep path="hyperswitch/crates/api_models/src/payment_methods.rs" role="context" start="2478" end="2478">
type Error = error_stack::Report<errors::ValidationError>;
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs<|crate|> hyperswitch_connectors<|connector|> adyen anchor=get_browser_info kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="1797" end="1818">
fn get_browser_info(item: &PaymentsAuthorizeRouterData) -> Result<Option<AdyenBrowserInfo>, Error> {
if item.auth_type == storage_enums::AuthenticationType::ThreeDs
|| item.payment_method == storage_enums::PaymentMethod::Card
|| item.payment_method == storage_enums::PaymentMethod::BankRedirect
|| item.request.payment_method_type == Some(storage_enums::PaymentMethodType::GoPay)
|| item.request.payment_method_type == Some(storage_enums::PaymentMethodType::GooglePay)
{
let info = item.request.get_browser_info()?;
Ok(Some(AdyenBrowserInfo {
accept_header: info.get_accept_header()?,
language: info.get_language()?,
screen_height: info.get_screen_height()?,
screen_width: info.get_screen_width()?,
color_depth: info.get_color_depth()?,
user_agent: info.get_user_agent()?,
time_zone_offset: info.get_time_zone()?,
java_enabled: info.get_java_enabled()?,
}))
} else {
Ok(None)
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="1796" end="1796">
use common_enums::enums as storage_enums;
use common_utils::{
errors::{CustomResult, ParsingError},
ext_traits::Encode,
pii::Email,
request::Method,
types::MinorUnit,
};
use hyperswitch_domain_models::{
network_tokenization::NetworkTokenNumber,
payment_method_data::{
BankDebitData, BankRedirectData, BankTransferData, Card, CardRedirectData, GiftCardData,
NetworkTokenData, PayLaterData, PaymentMethodData, VoucherData, WalletData,
},
router_data::{
ConnectorAuthType, ErrorResponse, PaymentMethodBalance, PaymentMethodToken, RouterData,
},
router_request_types::{PaymentsPreProcessingData, ResponseId, SubmitEvidenceRequestData},
router_response_types::{
AcceptDisputeResponse, DefendDisputeResponse, MandateReference, PaymentsResponseData,
RedirectForm, RefundsResponseData, SubmitEvidenceResponse,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsPreProcessingRouterData, RefundsRouterData,
},
};
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="1857" end="1864">
fn get_channel_type(pm_type: Option<storage_enums::PaymentMethodType>) -> Option<Channel> {
pm_type.as_ref().and_then(|pmt| match pmt {
storage_enums::PaymentMethodType::GoPay | storage_enums::PaymentMethodType::Vipps => {
Some(Channel::Web)
}
_ => None,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="1820" end="1855">
fn get_additional_data(item: &PaymentsAuthorizeRouterData) -> Option<AdditionalData> {
let (authorisation_type, manual_capture) = match item.request.capture_method {
Some(storage_enums::CaptureMethod::Manual) | Some(enums::CaptureMethod::ManualMultiple) => {
(Some(AuthType::PreAuth), Some("true".to_string()))
}
_ => (None, None),
};
let riskdata = item.request.metadata.clone().and_then(get_risk_data);
let execute_three_d = if matches!(item.auth_type, storage_enums::AuthenticationType::ThreeDs) {
Some("true".to_string())
} else {
None
};
if authorisation_type.is_none()
&& manual_capture.is_none()
&& execute_three_d.is_none()
&& riskdata.is_none()
{
//without this if-condition when the above 3 values are None, additionalData will be serialized to JSON like this -> additionalData: {}
//returning None, ensures that additionalData key will not be present in the serialized JSON
None
} else {
Some(AdditionalData {
authorisation_type,
manual_capture,
execute_three_d,
network_tx_reference: None,
recurring_detail_reference: None,
recurring_shopper_reference: None,
recurring_processing_model: None,
riskdata,
..AdditionalData::default()
})
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="1766" end="1795">
fn get_recurring_processing_model(
item: &PaymentsAuthorizeRouterData,
) -> Result<RecurringDetails, Error> {
match (item.request.setup_future_usage, item.request.off_session) {
(Some(storage_enums::FutureUsage::OffSession), _) => {
let customer_id = item.get_customer_id()?;
let shopper_reference = format!(
"{}_{}",
item.merchant_id.get_string_repr(),
customer_id.get_string_repr()
);
let store_payment_method = item.request.is_mandate_payment();
Ok((
Some(AdyenRecurringModel::UnscheduledCardOnFile),
Some(store_payment_method),
Some(shopper_reference),
))
}
(_, Some(true)) => Ok((
Some(AdyenRecurringModel::UnscheduledCardOnFile),
None,
Some(format!(
"{}_{}",
item.merchant_id.get_string_repr(),
item.get_customer_id()?.get_string_repr()
)),
)),
_ => Ok((None, None, None)),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="1757" end="1762">
fn from(item: &PaymentsAuthorizeRouterData) -> Self {
match item.request.off_session {
Some(true) => Self::ContinuedAuthentication,
_ => Self::Ecommerce,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="3027" end="3094">
fn try_from(
value: (&AdyenRouterData<&PaymentsAuthorizeRouterData>, &VoucherData),
) -> Result<Self, Self::Error> {
let (item, voucher_data) = value;
let amount = get_amount_data(item);
let auth_type = AdyenAuthType::try_from(&item.router_data.connector_auth_type)?;
let shopper_interaction = AdyenShopperInteraction::from(item.router_data);
let recurring_processing_model = get_recurring_processing_model(item.router_data)?.0;
let browser_info = get_browser_info(item.router_data)?;
let additional_data = get_additional_data(item.router_data);
let payment_method = PaymentMethod::AdyenPaymentMethod(Box::new(
AdyenPaymentMethod::try_from((voucher_data, item.router_data))?,
));
let return_url = item.router_data.request.get_router_return_url()?;
let social_security_number = get_social_security_number(voucher_data);
let billing_address =
get_address_info(item.router_data.get_optional_billing()).and_then(Result::ok);
let shopper_name = get_shopper_name(item.router_data.get_optional_billing());
let (store, splits) = match item.router_data.request.split_payments.as_ref() {
Some(common_types::payments::SplitPaymentsRequest::AdyenSplitPayment(
adyen_split_payment,
)) => get_adyen_split_request(adyen_split_payment, item.router_data.request.currency),
_ => (None, None),
};
let device_fingerprint = item
.router_data
.request
.metadata
.clone()
.and_then(get_device_fingerprint);
let delivery_address =
get_address_info(item.router_data.get_optional_shipping()).and_then(Result::ok);
let telephone_number = item.router_data.get_optional_billing_phone_number();
let request = AdyenPaymentRequest {
amount,
merchant_account: auth_type.merchant_account,
payment_method,
reference: item.router_data.connector_request_reference_id.to_string(),
return_url,
browser_info,
shopper_interaction,
recurring_processing_model,
additional_data,
shopper_name,
shopper_locale: None,
shopper_email: item.router_data.get_optional_billing_email(),
social_security_number,
mpi_data: None,
telephone_number,
billing_address,
delivery_address,
country_code: None,
line_items: None,
shopper_reference: None,
store_payment_method: None,
channel: None,
shopper_statement: item.router_data.request.statement_descriptor.clone(),
shopper_ip: item.router_data.request.get_ip_address_as_optional(),
merchant_order_reference: item.router_data.request.merchant_order_reference_id.clone(),
store,
splits,
device_fingerprint,
};
Ok(request)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="2948" end="3019">
fn try_from(
value: (
&AdyenRouterData<&PaymentsAuthorizeRouterData>,
&BankDebitData,
),
) -> Result<Self, Self::Error> {
let (item, bank_debit_data) = value;
let amount = get_amount_data(item);
let auth_type = AdyenAuthType::try_from(&item.router_data.connector_auth_type)?;
let shopper_interaction = AdyenShopperInteraction::from(item.router_data);
let (recurring_processing_model, store_payment_method, shopper_reference) =
get_recurring_processing_model(item.router_data)?;
let browser_info = get_browser_info(item.router_data)?;
let additional_data = get_additional_data(item.router_data);
let return_url = item.router_data.request.get_router_return_url()?;
let payment_method = PaymentMethod::AdyenPaymentMethod(Box::new(
AdyenPaymentMethod::try_from((bank_debit_data, item.router_data))?,
));
let country_code = get_country_code(item.router_data.get_optional_billing());
let (store, splits) = match item.router_data.request.split_payments.as_ref() {
Some(common_types::payments::SplitPaymentsRequest::AdyenSplitPayment(
adyen_split_payment,
)) => get_adyen_split_request(adyen_split_payment, item.router_data.request.currency),
_ => (None, None),
};
let device_fingerprint = item
.router_data
.request
.metadata
.clone()
.and_then(get_device_fingerprint);
let billing_address =
get_address_info(item.router_data.get_optional_billing()).and_then(Result::ok);
let delivery_address =
get_address_info(item.router_data.get_optional_shipping()).and_then(Result::ok);
let telephone_number = item.router_data.get_optional_billing_phone_number();
let request = AdyenPaymentRequest {
amount,
merchant_account: auth_type.merchant_account,
payment_method,
reference: item.router_data.connector_request_reference_id.clone(),
return_url,
browser_info,
shopper_interaction,
recurring_processing_model,
additional_data,
mpi_data: None,
shopper_name: None,
shopper_locale: None,
shopper_email: item.router_data.get_optional_billing_email(),
social_security_number: None,
telephone_number,
billing_address,
delivery_address,
country_code,
line_items: None,
shopper_reference,
store_payment_method,
channel: None,
shopper_statement: item.router_data.request.statement_descriptor.clone(),
shopper_ip: item.router_data.request.get_ip_address_as_optional(),
merchant_order_reference: item.router_data.request.merchant_order_reference_id.clone(),
store,
splits,
device_fingerprint,
};
Ok(request)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="66" end="66">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs" role="context" start="649" end="652">
pub enum PaymentMethod<'a> {
AdyenPaymentMethod(Box<AdyenPaymentMethod<'a>>),
AdyenMandatePaymentMethod(Box<AdyenMandate>),
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globalpay/response.rs" role="context" start="216" end="241">
pub struct Card {
/// Code generated when the card is successfully authorized.
pub authcode: Option<Secret<String>>,
/// The recommended AVS action to be taken by the agent processing the card transaction.
pub avs_action: Option<String>,
/// The result of the AVS address check.
pub avs_address_result: Option<String>,
/// The result of the AVS postal code check.
pub avs_postal_code_result: Option<String>,
/// Indicates the card brand that issued the card.
pub brand: Option<Brand>,
/// The unique reference created by the brands/schemes to uniquely identify the transaction.
pub brand_reference: Option<Secret<String>>,
/// The time returned by the card brand indicating when the transaction was processed on
/// their system.
pub brand_time_reference: Option<String>,
/// The result of the CVV check.
pub cvv_result: Option<String>,
/// Masked card number with last 4 digits showing.
pub masked_number_last4: Option<String>,
/// The result codes directly from the card issuer.
pub provider: Option<ProviderClass>,
/// The card EMV tag response data from the card issuer for a contactless or chip card
/// transaction.
pub tag_response: Option<Secret<String>>,
}
<file_sep path="hyperswitch/v2_compatible_migrations/2024-08-28-081721_add_v2_columns/up.sql" role="context" start="54" end="70">
ADD COLUMN redirection_data JSONB,
ADD COLUMN connector_payment_data TEXT,
ADD COLUMN connector_token_details JSONB;
-- Change the type of the column from JSON to JSONB
ALTER TABLE merchant_connector_account
ADD COLUMN IF NOT EXISTS feature_metadata JSONB;
ALTER TABLE payment_methods
ADD COLUMN IF NOT EXISTS locker_fingerprint_id VARCHAR(64),
ADD COLUMN IF NOT EXISTS payment_method_type_v2 VARCHAR(64),
ADD COLUMN IF NOT EXISTS payment_method_subtype VARCHAR(64);
ALTER TABLE refund
ADD COLUMN IF NOT EXISTS id VARCHAR(64),
ADD COLUMN IF NOT EXISTS merchant_reference_id VARCHAR(64),
ADD COLUMN IF NOT EXISTS connector_id VARCHAR(64);
<file_sep path="hyperswitch/crates/api_models/src/payment_methods.rs" role="context" start="1075" end="1083">
pub struct Card {
pub card_number: CardNumber,
pub name_on_card: Option<masking::Secret<String>>,
pub card_exp_month: masking::Secret<String>,
pub card_exp_year: masking::Secret<String>,
pub card_brand: Option<String>,
pub card_isin: Option<String>,
pub nick_name: Option<String>,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/bankofamerica/transformers.rs<|crate|> hyperswitch_connectors<|connector|> bankofamerica anchor=build_bill_to kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bankofamerica/transformers.rs" role="context" start="508" end="545">
fn build_bill_to(
address_details: Option<&hyperswitch_domain_models::address::Address>,
email: pii::Email,
) -> Result<BillTo, error_stack::Report<errors::ConnectorError>> {
let default_address = BillTo {
first_name: None,
last_name: None,
address1: None,
locality: None,
administrative_area: None,
postal_code: None,
country: None,
email: email.clone(),
};
Ok(address_details
.and_then(|addr| {
addr.address.as_ref().map(|addr| {
let administrative_area = addr.to_state_code_as_optional().unwrap_or_else(|_| {
addr.state
.clone()
.map(|state| Secret::new(format!("{:.20}", state.expose())))
});
BillTo {
first_name: addr.first_name.clone(),
last_name: addr.last_name.clone(),
address1: addr.line1.clone(),
locality: addr.city.clone(),
administrative_area,
postal_code: addr.zip.clone(),
country: addr.country,
email,
}
})
})
.unwrap_or(default_address))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bankofamerica/transformers.rs" role="context" start="507" end="507">
use hyperswitch_domain_models::{
payment_method_data::{
ApplePayWalletData, GooglePayWalletData, PaymentMethodData, SamsungPayWalletData,
WalletData,
},
router_data::{
AdditionalPaymentMethodConnectorResponse, ApplePayPredecryptData, ConnectorAuthType,
ConnectorResponseData, ErrorResponse, PaymentMethodToken, RouterData,
},
router_flow_types::refunds::{Execute, RSync},
router_request_types::{
PaymentsAuthorizeData, PaymentsCancelData, PaymentsCaptureData, PaymentsSyncData,
ResponseId,
},
router_response_types::{MandateReference, PaymentsResponseData, RefundsResponseData},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
RefundsRouterData, SetupMandateRouterData,
},
};
use masking::{ExposeInterface, PeekInterface, Secret};
use error_stack::ResultExt;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bankofamerica/transformers.rs" role="context" start="571" end="578">
fn from(solution: PaymentSolution) -> Self {
let payment_solution = match solution {
PaymentSolution::ApplePay => "001",
PaymentSolution::GooglePay => "012",
PaymentSolution::SamsungPay => "008",
};
payment_solution.to_string()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bankofamerica/transformers.rs" role="context" start="547" end="561">
fn get_boa_card_type(card_network: common_enums::CardNetwork) -> Option<&'static str> {
match card_network {
common_enums::CardNetwork::Visa => Some("001"),
common_enums::CardNetwork::Mastercard => Some("002"),
common_enums::CardNetwork::AmericanExpress => Some("003"),
common_enums::CardNetwork::JCB => Some("007"),
common_enums::CardNetwork::DinersClub => Some("005"),
common_enums::CardNetwork::Discover => Some("004"),
common_enums::CardNetwork::CartesBancaires => Some("006"),
common_enums::CardNetwork::UnionPay => Some("062"),
//"042" is the type code for Masetro Cards(International). For Maestro Cards(UK-Domestic) the mapping should be "024"
common_enums::CardNetwork::Maestro => Some("042"),
common_enums::CardNetwork::Interac | common_enums::CardNetwork::RuPay => None,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bankofamerica/transformers.rs" role="context" start="364" end="461">
fn try_from(
item: ResponseRouterData<F, BankOfAmericaSetupMandatesResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
match item.response {
BankOfAmericaSetupMandatesResponse::ClientReferenceInformation(info_response) => {
let mandate_reference =
info_response
.token_information
.clone()
.map(|token_info| MandateReference {
connector_mandate_id: token_info
.payment_instrument
.map(|payment_instrument| payment_instrument.id.expose()),
payment_method_id: None,
mandate_metadata: None,
connector_mandate_request_reference_id: None,
});
let mut mandate_status =
map_boa_attempt_status((info_response.status.clone(), false));
if matches!(mandate_status, enums::AttemptStatus::Authorized) {
//In case of zero auth mandates we want to make the payment reach the terminal status so we are converting the authorized status to charged as well.
mandate_status = enums::AttemptStatus::Charged
}
let error_response =
get_error_response_if_failure((&info_response, mandate_status, item.http_code));
let connector_response = match item.data.payment_method {
common_enums::PaymentMethod::Card => info_response
.processor_information
.as_ref()
.and_then(|processor_information| {
info_response
.consumer_authentication_information
.as_ref()
.map(|consumer_auth_information| {
convert_to_additional_payment_method_connector_response(
processor_information,
consumer_auth_information,
)
})
})
.map(ConnectorResponseData::with_additional_payment_method_data),
common_enums::PaymentMethod::CardRedirect
| common_enums::PaymentMethod::PayLater
| common_enums::PaymentMethod::Wallet
| common_enums::PaymentMethod::BankRedirect
| common_enums::PaymentMethod::BankTransfer
| common_enums::PaymentMethod::Crypto
| common_enums::PaymentMethod::BankDebit
| common_enums::PaymentMethod::Reward
| common_enums::PaymentMethod::RealTimePayment
| common_enums::PaymentMethod::MobilePayment
| common_enums::PaymentMethod::Upi
| common_enums::PaymentMethod::Voucher
| common_enums::PaymentMethod::OpenBanking
| common_enums::PaymentMethod::GiftCard => None,
};
Ok(Self {
status: mandate_status,
response: match error_response {
Some(error) => Err(error),
None => Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
info_response.id.clone(),
),
redirection_data: Box::new(None),
mandate_reference: Box::new(mandate_reference),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(
info_response
.client_reference_information
.code
.clone()
.unwrap_or(info_response.id),
),
incremental_authorization_allowed: None,
charges: None,
}),
},
connector_response,
..item.data
})
}
BankOfAmericaSetupMandatesResponse::ErrorInformation(error_response) => {
let response = Err(convert_to_error_response_from_error_info(
&error_response,
item.http_code,
));
Ok(Self {
response,
status: enums::AttemptStatus::Failure,
..item.data
})
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bankofamerica/transformers.rs" role="context" start="298" end="356">
fn try_from(item: &SetupMandateRouterData) -> Result<Self, Self::Error> {
match item.request.payment_method_data.clone() {
PaymentMethodData::Card(card_data) => Self::try_from((item, card_data)),
PaymentMethodData::Wallet(wallet_data) => match wallet_data {
WalletData::ApplePay(apple_pay_data) => Self::try_from((item, apple_pay_data)),
WalletData::GooglePay(google_pay_data) => Self::try_from((item, google_pay_data)),
WalletData::AliPayQr(_)
| WalletData::AliPayRedirect(_)
| WalletData::AliPayHkRedirect(_)
| WalletData::AmazonPayRedirect(_)
| WalletData::MomoRedirect(_)
| WalletData::KakaoPayRedirect(_)
| WalletData::GoPayRedirect(_)
| WalletData::GcashRedirect(_)
| WalletData::ApplePayRedirect(_)
| WalletData::ApplePayThirdPartySdk(_)
| WalletData::DanaRedirect {}
| WalletData::GooglePayRedirect(_)
| WalletData::GooglePayThirdPartySdk(_)
| WalletData::MbWayRedirect(_)
| WalletData::MobilePayRedirect(_)
| WalletData::PaypalRedirect(_)
| WalletData::PaypalSdk(_)
| WalletData::Paze(_)
| WalletData::SamsungPay(_)
| WalletData::TwintRedirect {}
| WalletData::VippsRedirect {}
| WalletData::TouchNGoRedirect(_)
| WalletData::WeChatPayRedirect(_)
| WalletData::WeChatPayQr(_)
| WalletData::CashappQr(_)
| WalletData::SwishQr(_)
| WalletData::Mifinity(_) => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("BankOfAmerica"),
))?,
},
PaymentMethodData::CardRedirect(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message("BankOfAmerica"),
))?
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bankofamerica/transformers.rs" role="context" start="990" end="1151">
fn try_from(
item: &BankOfAmericaRouterData<&PaymentsAuthorizeRouterData>,
) -> Result<Self, Self::Error> {
match item.router_data.request.connector_mandate_id() {
Some(connector_mandate_id) => Self::try_from((item, connector_mandate_id)),
None => {
match item.router_data.request.payment_method_data.clone() {
PaymentMethodData::Card(ccard) => Self::try_from((item, ccard)),
PaymentMethodData::Wallet(wallet_data) => match wallet_data {
WalletData::ApplePay(apple_pay_data) => {
match item.router_data.payment_method_token.clone() {
Some(payment_method_token) => match payment_method_token {
PaymentMethodToken::ApplePayDecrypt(decrypt_data) => {
Self::try_from((item, decrypt_data, apple_pay_data))
}
PaymentMethodToken::Token(_) => {
Err(unimplemented_payment_method!(
"Apple Pay",
"Manual",
"Bank Of America"
))?
}
PaymentMethodToken::PazeDecrypt(_) => Err(
unimplemented_payment_method!("Paze", "Bank Of America"),
)?,
PaymentMethodToken::GooglePayDecrypt(_) => {
Err(unimplemented_payment_method!(
"Google Pay",
"Bank Of America"
))?
}
},
None => {
let email = item.router_data.request.get_email()?;
let bill_to = build_bill_to(
item.router_data.get_optional_billing(),
email,
)?;
let order_information: OrderInformationWithBill =
OrderInformationWithBill::from((item, Some(bill_to)));
let processing_information =
ProcessingInformation::try_from((
item,
Some(PaymentSolution::ApplePay),
Some(apple_pay_data.payment_method.network.clone()),
))?;
let client_reference_information =
ClientReferenceInformation::from(item);
let payment_information =
PaymentInformation::from(&apple_pay_data);
let merchant_defined_information = item
.router_data
.request
.metadata
.clone()
.map(convert_metadata_to_merchant_defined_info);
let ucaf_collection_indicator = match apple_pay_data
.payment_method
.network
.to_lowercase()
.as_str()
{
"mastercard" => Some("2".to_string()),
_ => None,
};
Ok(Self {
processing_information,
payment_information,
order_information,
merchant_defined_information,
client_reference_information,
consumer_authentication_information: Some(
BankOfAmericaConsumerAuthInformation {
ucaf_collection_indicator,
cavv: None,
ucaf_authentication_data: None,
xid: None,
directory_server_transaction_id: None,
specification_version: None,
},
),
})
}
}
}
WalletData::GooglePay(google_pay_data) => {
Self::try_from((item, google_pay_data))
}
WalletData::SamsungPay(samsung_pay_data) => {
Self::try_from((item, samsung_pay_data))
}
WalletData::AliPayQr(_)
| WalletData::AliPayRedirect(_)
| WalletData::AliPayHkRedirect(_)
| WalletData::AmazonPayRedirect(_)
| WalletData::MomoRedirect(_)
| WalletData::KakaoPayRedirect(_)
| WalletData::GoPayRedirect(_)
| WalletData::GcashRedirect(_)
| WalletData::ApplePayRedirect(_)
| WalletData::ApplePayThirdPartySdk(_)
| WalletData::DanaRedirect {}
| WalletData::GooglePayRedirect(_)
| WalletData::GooglePayThirdPartySdk(_)
| WalletData::MbWayRedirect(_)
| WalletData::MobilePayRedirect(_)
| WalletData::PaypalRedirect(_)
| WalletData::PaypalSdk(_)
| WalletData::Paze(_)
| WalletData::TwintRedirect {}
| WalletData::VippsRedirect {}
| WalletData::TouchNGoRedirect(_)
| WalletData::WeChatPayRedirect(_)
| WalletData::WeChatPayQr(_)
| WalletData::CashappQr(_)
| WalletData::SwishQr(_)
| WalletData::Mifinity(_) => Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message(
"Bank of America",
),
)
.into()),
},
// If connector_mandate_id is present MandatePayment will be the PMD, the case will be handled in the first `if` clause.
// This is a fallback implementation in the event of catastrophe.
PaymentMethodData::MandatePayment => {
let connector_mandate_id =
item.router_data.request.connector_mandate_id().ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "connector_mandate_id",
},
)?;
Self::try_from((item, connector_mandate_id))
}
PaymentMethodData::CardRedirect(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {
Err(errors::ConnectorError::NotImplemented(
utils::get_unimplemented_payment_method_error_message(
"Bank of America",
),
)
.into())
}
}
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bankofamerica/transformers.rs" role="context" start="877" end="924">
fn try_from(
(item, apple_pay_data, apple_pay_wallet_data): (
&BankOfAmericaRouterData<&PaymentsAuthorizeRouterData>,
Box<ApplePayPredecryptData>,
ApplePayWalletData,
),
) -> Result<Self, Self::Error> {
let email = item.router_data.request.get_email()?;
let bill_to = build_bill_to(item.router_data.get_optional_billing(), email)?;
let order_information = OrderInformationWithBill::from((item, Some(bill_to)));
let processing_information = ProcessingInformation::try_from((
item,
Some(PaymentSolution::ApplePay),
Some(apple_pay_wallet_data.payment_method.network.clone()),
))?;
let client_reference_information = ClientReferenceInformation::from(item);
let payment_information = PaymentInformation::try_from(&apple_pay_data)?;
let merchant_defined_information = item
.router_data
.request
.metadata
.clone()
.map(convert_metadata_to_merchant_defined_info);
let ucaf_collection_indicator = match apple_pay_wallet_data
.payment_method
.network
.to_lowercase()
.as_str()
{
"mastercard" => Some("2".to_string()),
_ => None,
};
Ok(Self {
processing_information,
payment_information,
order_information,
client_reference_information,
merchant_defined_information,
consumer_authentication_information: Some(BankOfAmericaConsumerAuthInformation {
ucaf_collection_indicator,
cavv: None,
ucaf_authentication_data: None,
xid: None,
directory_server_transaction_id: None,
specification_version: None,
}),
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bankofamerica/transformers.rs" role="context" start="283" end="294">
pub struct BillTo {
first_name: Option<Secret<String>>,
last_name: Option<Secret<String>>,
address1: Option<Secret<String>>,
locality: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
administrative_area: Option<Secret<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
postal_code: Option<Secret<String>>,
country: Option<enums::CountryAlpha2>,
email: pii::Email,
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globalpay/requests.rs" role="context" start="301" end="318">
pub struct Address {
/// Merchant defined field common to all transactions that are part of the same order.
pub city: Option<Secret<String>>,
/// The country in ISO-3166-1(alpha-2 code) format.
pub country: Option<String>,
/// First line of the address.
pub line_1: Option<Secret<String>>,
/// Second line of the address.
pub line_2: Option<Secret<String>>,
/// Third line of the address.
pub line_3: Option<Secret<String>>,
/// The city or town of the address.
pub postal_code: Option<Secret<String>>,
/// The state or region of the address. ISO 3166-2 minus the country code itself. For
/// example, US Illinois = IL, or in the case of GB counties Wiltshire = WI or Aberdeenshire
/// = ABD
pub state: Option<String>,
}
<file_sep path="hyperswitch/migrations/2025-02-06-111828_drop_int_id_column_accross_database/up.sql" role="context" start="20" end="36">
------------------------ Payment Attempt -----------------------
ALTER TABLE payment_attempt DROP COLUMN id;
------------------------ Payment Methods -----------------------
ALTER TABLE payment_methods DROP COLUMN IF EXISTS id;
------------------------ Address -----------------------
ALTER TABLE address DROP COLUMN IF EXISTS id;
------------------------ Dispute -----------------------
ALTER TABLE dispute DROP COLUMN IF EXISTS id;
------------------------ Mandate -----------------------
ALTER TABLE mandate DROP COLUMN IF EXISTS id;
------------------------ Refund -----------------------
<file_sep path="hyperswitch/crates/api_models/src/payments.rs" role="context" start="4244" end="4252">
pub struct Address {
/// Provide the address details
pub address: Option<AddressDetails>,
pub phone: Option<PhoneDetails>,
#[schema(value_type = Option<String>)]
pub email: Option<Email>,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/thunes.rs<|crate|> hyperswitch_connectors<|connector|> thunes anchor=new kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/thunes.rs" role="context" start="50" end="54">
pub fn new() -> &'static Self {
&Self {
amount_converter: &StringMinorUnitForConnector,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/thunes.rs" role="context" start="49" end="49">
use common_utils::{
errors::CustomResult,
ext_traits::BytesExt,
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, StringMinorUnit, StringMinorUnitForConnector},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/thunes.rs" role="context" start="96" end="98">
fn id(&self) -> &'static str {
"thunes"
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/thunes.rs" role="context" start="80" end="92">
fn build_headers(
&self,
req: &RouterData<Flow, Request, Response>,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
let mut header = vec![(
headers::CONTENT_TYPE.to_string(),
self.get_content_type().to_string().into(),
)];
let mut api_key = self.get_auth_header(&req.connector_auth_type)?;
header.append(&mut api_key);
Ok(header)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/thunes.rs" role="context" start="433" end="450">
fn build_request(
&self,
req: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Post)
.url(&types::RefundExecuteType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::RefundExecuteType::get_headers(
self, req, connectors,
)?)
.set_body(types::RefundExecuteType::get_request_body(
self, req, connectors,
)?)
.build();
Ok(Some(request))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/thunes.rs" role="context" start="203" end="223">
fn build_request(
&self,
req: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsAuthorizeType::get_url(
self, req, connectors,
)?)
.attach_default_headers()
.headers(types::PaymentsAuthorizeType::get_headers(
self, req, connectors,
)?)
.set_body(types::PaymentsAuthorizeType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/amazonpay.rs<|crate|> hyperswitch_connectors<|connector|> amazonpay anchor=new kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/amazonpay.rs" role="context" start="50" end="54">
pub fn new() -> &'static Self {
&Self {
amount_converter: &StringMinorUnitForConnector,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/amazonpay.rs" role="context" start="49" end="49">
use common_utils::{
errors::CustomResult,
ext_traits::BytesExt,
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, StringMinorUnit, StringMinorUnitForConnector},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/amazonpay.rs" role="context" start="96" end="98">
fn id(&self) -> &'static str {
"amazonpay"
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/amazonpay.rs" role="context" start="80" end="92">
fn build_headers(
&self,
req: &RouterData<Flow, Request, Response>,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
let mut header = vec![(
headers::CONTENT_TYPE.to_string(),
self.get_content_type().to_string().into(),
)];
let mut api_key = self.get_auth_header(&req.connector_auth_type)?;
header.append(&mut api_key);
Ok(header)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/amazonpay.rs" role="context" start="421" end="435">
fn get_request_body(
&self,
req: &RefundsRouterData<Execute>,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let refund_amount = utils::convert_amount(
self.amount_converter,
req.request.minor_refund_amount,
req.request.currency,
)?;
let connector_router_data = amazonpay::AmazonpayRouterData::from((refund_amount, req));
let connector_req = amazonpay::AmazonpayRefundRequest::try_from(&connector_router_data)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/amazonpay.rs" role="context" start="278" end="291">
fn build_request(
&self,
req: &PaymentsSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&types::PaymentsSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsSyncType::get_headers(self, req, connectors)?)
.build(),
))
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/juspaythreedsserver.rs<|crate|> hyperswitch_connectors<|connector|> juspaythreedsserver anchor=new kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/juspaythreedsserver.rs" role="context" start="56" end="60">
pub fn new() -> &'static Self {
&Self {
amount_converter: &StringMinorUnitForConnector,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/juspaythreedsserver.rs" role="context" start="55" end="55">
use common_utils::{
errors::CustomResult,
ext_traits::BytesExt,
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, StringMinorUnit, StringMinorUnitForConnector},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/juspaythreedsserver.rs" role="context" start="139" end="141">
fn id(&self) -> &'static str {
"juspaythreedsserver"
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/juspaythreedsserver.rs" role="context" start="123" end="135">
fn build_headers(
&self,
req: &RouterData<Flow, Request, Response>,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
let mut header = vec![(
headers::CONTENT_TYPE.to_string(),
self.get_content_type().to_string().into(),
)];
let mut api_key = self.get_auth_header(&req.connector_auth_type)?;
header.append(&mut api_key);
Ok(header)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/juspaythreedsserver.rs" role="context" start="404" end="422">
fn build_request(
&self,
req: &PaymentsCaptureRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsCaptureType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsCaptureType::get_headers(
self, req, connectors,
)?)
.set_body(types::PaymentsCaptureType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/juspaythreedsserver.rs" role="context" start="330" end="343">
fn build_request(
&self,
req: &PaymentsSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&types::PaymentsSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsSyncType::get_headers(self, req, connectors)?)
.build(),
))
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/bankofamerica.rs<|crate|> hyperswitch_connectors<|connector|> bankofamerica anchor=get_headers kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bankofamerica.rs" role="context" start="979" end="985">
fn get_headers(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bankofamerica.rs" role="context" start="978" end="978">
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
}
impl ConnectorIntegration<RSync, RefundsData, RefundsResponseData> for Bankofamerica {
fn get_headers(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_http_method(&self) -> Method {
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bankofamerica.rs" role="context" start="991" end="993">
fn get_http_method(&self) -> Method {
Method::Get
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bankofamerica.rs" role="context" start="987" end="989">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bankofamerica.rs" role="context" start="969" end="975">
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bankofamerica.rs" role="context" start="948" end="967">
fn handle_response(
&self,
data: &RefundsRouterData<Execute>,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundsRouterData<Execute>, errors::ConnectorError> {
let response: bankofamerica::BankOfAmericaRefundResponse = res
.response
.parse_struct("bankofamerica RefundResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bankofamerica.rs" role="context" start="608" end="621">
fn build_request(
&self,
req: &PaymentsSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&PaymentsSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(PaymentsSyncType::get_headers(self, req, connectors)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bankofamerica.rs" role="context" start="818" end="832">
fn build_request(
&self,
req: &PaymentsCancelRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&PaymentsVoidType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(PaymentsVoidType::get_headers(self, req, connectors)?)
.set_body(PaymentsVoidType::get_request_body(self, req, connectors)?)
.build(),
))
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/datatrans.rs<|crate|> hyperswitch_connectors<|connector|> datatrans anchor=get_headers kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/datatrans.rs" role="context" start="721" end="727">
fn get_headers(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/datatrans.rs" role="context" start="720" end="720">
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
}
impl ConnectorIntegration<RSync, RefundsData, RefundsResponseData> for Datatrans {
fn get_headers(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/datatrans.rs" role="context" start="733" end="741">
fn get_url(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let connector_refund_id = req.request.get_connector_refund_id()?;
let base_url = self.base_url(connectors);
Ok(format!("{base_url}v1/transactions/{connector_refund_id}"))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/datatrans.rs" role="context" start="729" end="731">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/datatrans.rs" role="context" start="711" end="717">
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/datatrans.rs" role="context" start="691" end="709">
fn handle_response(
&self,
data: &RefundsRouterData<Execute>,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundsRouterData<Execute>, errors::ConnectorError> {
let response: datatrans::DatatransRefundsResponse = res
.response
.parse_struct("datatrans DatatransRefundsResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/datatrans.rs" role="context" start="672" end="689">
fn build_request(
&self,
req: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Post)
.url(&types::RefundExecuteType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::RefundExecuteType::get_headers(
self, req, connectors,
)?)
.set_body(types::RefundExecuteType::get_request_body(
self, req, connectors,
)?)
.build();
Ok(Some(request))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/datatrans.rs" role="context" start="743" end="759">
fn build_request(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&types::RefundSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::RefundSyncType::get_headers(self, req, connectors)?)
.set_body(types::RefundSyncType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/bambora.rs<|crate|> hyperswitch_connectors<|connector|> bambora anchor=get_headers kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bambora.rs" role="context" start="727" end="733">
fn get_headers(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bambora.rs" role="context" start="726" end="726">
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
}
impl ConnectorIntegration<RSync, RefundsData, RefundsResponseData> for Bambora {
fn get_headers(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bambora.rs" role="context" start="739" end="751">
fn get_url(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let _connector_payment_id = req.request.connector_transaction_id.clone();
let connector_refund_id = req.request.get_connector_refund_id()?;
Ok(format!(
"{}/v1/payments/{}",
self.base_url(connectors),
connector_refund_id
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bambora.rs" role="context" start="735" end="737">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bambora.rs" role="context" start="717" end="723">
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bambora.rs" role="context" start="695" end="715">
fn handle_response(
&self,
data: &RefundsRouterData<Execute>,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundsRouterData<Execute>, errors::ConnectorError> {
let response: bambora::RefundResponse = res
.response
.parse_struct("bambora RefundResponse")
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bambora.rs" role="context" start="753" end="766">
fn build_request(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&types::RefundSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::RefundSyncType::get_headers(self, req, connectors)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bambora.rs" role="context" start="305" end="324">
fn build_request(
&self,
req: &PaymentsCompleteAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Post)
.url(&PaymentsCompleteAuthorizeType::get_url(
self, req, connectors,
)?)
.attach_default_headers()
.headers(PaymentsCompleteAuthorizeType::get_headers(
self, req, connectors,
)?)
.set_body(PaymentsCompleteAuthorizeType::get_request_body(
self, req, connectors,
)?)
.build();
Ok(Some(request))
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/payu.rs<|crate|> hyperswitch_connectors<|connector|> payu anchor=get_headers kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payu.rs" role="context" start="702" end="708">
fn get_headers(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payu.rs" role="context" start="701" end="701">
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
}
impl ConnectorIntegration<RSync, RefundsData, RefundsResponseData> for Payu {
fn get_headers(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payu.rs" role="context" start="714" end="726">
fn get_url(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}{}{}{}",
self.base_url(connectors),
"api/v2_1/orders/",
req.request.connector_transaction_id,
"/refunds"
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payu.rs" role="context" start="710" end="712">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payu.rs" role="context" start="692" end="698">
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payu.rs" role="context" start="672" end="690">
fn handle_response(
&self,
data: &RefundsRouterData<Execute>,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundsRouterData<Execute>, errors::ConnectorError> {
let response: payu::RefundResponse = res
.response
.parse_struct("payu RefundResponse")
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payu.rs" role="context" start="563" end="579">
fn build_request(
&self,
req: &RouterData<Authorize, PaymentsAuthorizeData, PaymentsResponseData>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&PaymentsAuthorizeType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(PaymentsAuthorizeType::get_headers(self, req, connectors)?)
.set_body(PaymentsAuthorizeType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payu.rs" role="context" start="728" end="741">
fn build_request(
&self,
req: &RefundsRouterData<RSync>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&RefundSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(RefundSyncType::get_headers(self, req, connectors)?)
.build(),
))
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank.rs<|crate|> hyperswitch_connectors<|connector|> deutschebank anchor=get_headers kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank.rs" role="context" start="915" end="921">
fn get_headers(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank.rs" role="context" start="914" end="914">
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
}
impl ConnectorIntegration<RSync, RefundsData, RefundsResponseData> for Deutschebank {
fn get_headers(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank.rs" role="context" start="927" end="937">
fn get_url(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let tx_id = req.request.get_connector_refund_id()?;
Ok(format!(
"{}/services/v2.1/payment/tx/{tx_id}",
self.base_url(connectors)
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank.rs" role="context" start="923" end="925">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank.rs" role="context" start="905" end="911">
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank.rs" role="context" start="886" end="903">
fn handle_response(
&self,
data: &RefundsRouterData<Execute>,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundsRouterData<Execute>, errors::ConnectorError> {
let response: deutschebank::DeutschebankPaymentsResponse = res
.response
.parse_struct("DeutschebankPaymentsResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank.rs" role="context" start="939" end="952">
fn build_request(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&types::RefundSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::RefundSyncType::get_headers(self, req, connectors)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/deutschebank.rs" role="context" start="694" end="712">
fn build_request(
&self,
req: &PaymentsCaptureRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsCaptureType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsCaptureType::get_headers(
self, req, connectors,
)?)
.set_body(types::PaymentsCaptureType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/hipay.rs<|crate|> hyperswitch_connectors<|connector|> hipay anchor=get_headers kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/hipay.rs" role="context" start="680" end="686">
fn get_headers(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/hipay.rs" role="context" start="679" end="679">
use common_utils::{
consts::BASE64_ENGINE,
errors::{self as common_errors, CustomResult},
ext_traits::BytesExt,
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, StringMajorUnit, StringMajorUnitForConnector},
};
use hyperswitch_domain_models::{
router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::{
access_token_auth::AccessTokenAuth,
payments::{Authorize, Capture, PSync, PaymentMethodToken, Session, SetupMandate, Void},
refunds::{Execute, RSync},
},
router_request_types::{
AccessTokenRequestData, PaymentMethodTokenizationData, PaymentsAuthorizeData,
PaymentsCancelData, PaymentsCaptureData, PaymentsSessionData, PaymentsSyncData,
RefundsData, SetupMandateRequestData,
},
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsSyncRouterData, RefundSyncRouterData, RefundsRouterData, TokenizationRouterData,
},
};
use hyperswitch_interfaces::{
api::{
self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorSpecifications,
ConnectorValidation,
},
configs::Connectors,
errors,
events::connector_api_logs::ConnectorEvent,
types::{self, Response, TokenizationType},
webhooks,
};
use masking::{Mask, PeekInterface};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/hipay.rs" role="context" start="701" end="717">
fn build_request(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&types::RefundSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::RefundSyncType::get_headers(self, req, connectors)?)
.set_body(types::RefundSyncType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/hipay.rs" role="context" start="688" end="699">
fn get_url(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let connector_payment_id = req.request.connector_transaction_id.clone();
Ok(format!(
"{}v3/transaction/{}",
connectors.hipay.third_base_url.clone(),
connector_payment_id
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/hipay.rs" role="context" start="670" end="676">
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/hipay.rs" role="context" start="651" end="668">
fn handle_response(
&self,
data: &RefundsRouterData<Execute>,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundsRouterData<Execute>, errors::ConnectorError> {
let response: hipay::HipayMaintenanceResponse<hipay::RefundStatus> = res
.response
.parse_struct("hipay RefundResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/hipay.rs" role="context" start="319" end="338">
fn build_request(
&self,
req: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsAuthorizeType::get_url(
self, req, connectors,
)?)
.headers(types::PaymentsAuthorizeType::get_headers(
self, req, connectors,
)?)
.set_body(types::PaymentsAuthorizeType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/hipay.rs" role="context" start="545" end="559">
fn build_request(
&self,
req: &PaymentsCancelRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsVoidType::get_url(self, req, connectors)?)
.headers(types::PaymentsVoidType::get_headers(self, req, connectors)?)
.set_body(types::PaymentsVoidType::get_request_body(
self, req, connectors,
)?)
.build();
Ok(Some(request))
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/klarna.rs<|crate|> hyperswitch_connectors<|connector|> klarna anchor=get_headers kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/klarna.rs" role="context" start="1279" end="1285">
fn get_headers(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/klarna.rs" role="context" start="1278" end="1278">
use common_utils::{
consts::BASE64_ENGINE,
errors::CustomResult,
ext_traits::BytesExt,
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, MinorUnit, MinorUnitForConnector},
};
use hyperswitch_domain_models::{
payment_method_data::{PayLaterData, PaymentMethodData},
router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::{
access_token_auth::AccessTokenAuth,
payments::{Authorize, Capture, PSync, PaymentMethodToken, Session, SetupMandate, Void},
refunds::{Execute, RSync},
},
router_request_types::{
AccessTokenRequestData, PaymentMethodTokenizationData, PaymentsAuthorizeData,
PaymentsCancelData, PaymentsCaptureData, PaymentsSessionData, PaymentsSyncData,
RefundsData, SetupMandateRequestData,
},
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsSessionRouterData, PaymentsSyncRouterData, RefundSyncRouterData, RefundsRouterData,
},
};
use hyperswitch_interfaces::{
api::{
self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorSpecifications,
ConnectorValidation,
},
configs::Connectors,
consts::NO_ERROR_MESSAGE,
errors,
events::connector_api_logs::ConnectorEvent,
types::{self, Response},
webhooks::{IncomingWebhook, IncomingWebhookRequestDetails},
};
use masking::{Mask, PeekInterface};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/klarna.rs" role="context" start="1291" end="1304">
fn get_url(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let order_id = req.request.connector_transaction_id.clone();
let refund_id = req.request.get_connector_refund_id()?;
let endpoint =
build_region_specific_endpoint(self.base_url(connectors), &req.connector_meta_data)?;
Ok(format!(
"{endpoint}ordermanagement/v1/orders/{order_id}/refunds/{refund_id}"
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/klarna.rs" role="context" start="1287" end="1289">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/klarna.rs" role="context" start="1269" end="1275">
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/klarna.rs" role="context" start="1241" end="1267">
fn handle_response(
&self,
data: &RefundsRouterData<Execute>,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundsRouterData<Execute>, errors::ConnectorError> {
match res.headers {
Some(headers) => {
let refund_id = get_http_header("Refund-Id", &headers)
.attach_printable("Missing refund id in headers")
.change_context(errors::ConnectorError::ResponseHandlingFailed)?;
let response = klarna::KlarnaRefundResponse {
refund_id: refund_id.to_owned(),
};
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
}
None => Err(errors::ConnectorError::ResponseDeserializationFailed)
.attach_printable("Expected headers, but received no headers in response")?,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/klarna.rs" role="context" start="1222" end="1239">
fn build_request(
&self,
req: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Post)
.url(&types::RefundExecuteType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::RefundExecuteType::get_headers(
self, req, connectors,
)?)
.set_body(types::RefundExecuteType::get_request_body(
self, req, connectors,
)?)
.build();
Ok(Some(request))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/klarna.rs" role="context" start="461" end="474">
fn build_request(
&self,
req: &PaymentsSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&types::PaymentsSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsSyncType::get_headers(self, req, connectors)?)
.build(),
))
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/shift4.rs<|crate|> hyperswitch_connectors<|connector|> shift4 anchor=get_headers kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/shift4.rs" role="context" start="723" end="729">
fn get_headers(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/shift4.rs" role="context" start="722" end="722">
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
}
impl ConnectorIntegration<RSync, RefundsData, RefundsResponseData> for Shift4 {
fn get_headers(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/shift4.rs" role="context" start="735" end="746">
fn get_url(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let refund_id = req.request.get_connector_refund_id()?;
Ok(format!(
"{}refunds/{}",
self.base_url(connectors),
refund_id
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/shift4.rs" role="context" start="731" end="733">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/shift4.rs" role="context" start="713" end="719">
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/shift4.rs" role="context" start="691" end="711">
fn handle_response(
&self,
data: &RefundsRouterData<Execute>,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundsRouterData<Execute>, errors::ConnectorError> {
let response: shift4::RefundResponse = res
.response
.parse_struct("RefundResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/shift4.rs" role="context" start="311" end="324">
fn build_request(
&self,
req: &PaymentsSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&types::PaymentsSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsSyncType::get_headers(self, req, connectors)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/shift4.rs" role="context" start="493" end="513">
fn build_request(
&self,
req: &PaymentsPreProcessingRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsPreProcessingType::get_url(
self, req, connectors,
)?)
.attach_default_headers()
.headers(types::PaymentsPreProcessingType::get_headers(
self, req, connectors,
)?)
.set_body(types::PaymentsPreProcessingType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/billwerk.rs<|crate|> hyperswitch_connectors<|connector|> billwerk anchor=get_headers kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/billwerk.rs" role="context" start="709" end="715">
fn get_headers(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/billwerk.rs" role="context" start="708" end="708">
}
fn get_5xx_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
}
impl ConnectorIntegration<RSync, RefundsData, RefundsResponseData> for Billwerk {
fn get_headers(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/billwerk.rs" role="context" start="721" end="731">
fn get_url(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let refund_id = req.request.get_connector_refund_id()?;
Ok(format!(
"{}v1/refund/{refund_id}",
self.base_url(connectors)
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/billwerk.rs" role="context" start="717" end="719">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/billwerk.rs" role="context" start="699" end="705">
fn get_5xx_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/billwerk.rs" role="context" start="691" end="697">
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/billwerk.rs" role="context" start="565" end="578">
fn build_request(
&self,
req: &PaymentsCancelRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsVoidType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsVoidType::get_headers(self, req, connectors)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/billwerk.rs" role="context" start="309" end="329">
fn build_request(
&self,
req: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsAuthorizeType::get_url(
self, req, connectors,
)?)
.attach_default_headers()
.headers(types::PaymentsAuthorizeType::get_headers(
self, req, connectors,
)?)
.set_body(types::PaymentsAuthorizeType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/moneris.rs<|crate|> hyperswitch_connectors<|connector|> moneris anchor=get_headers kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/moneris.rs" role="context" start="731" end="737">
fn get_headers(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/moneris.rs" role="context" start="730" end="730">
}
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
}
impl ConnectorIntegration<RSync, RefundsData, RefundsResponseData> for Moneris {
fn get_headers(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/moneris.rs" role="context" start="743" end="750">
fn get_url(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let refund_id = req.request.get_connector_refund_id()?;
Ok(format!("{}/refunds/{refund_id}", self.base_url(connectors)))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/moneris.rs" role="context" start="739" end="741">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/moneris.rs" role="context" start="721" end="727">
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/moneris.rs" role="context" start="702" end="719">
fn handle_response(
&self,
data: &RefundsRouterData<Execute>,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundsRouterData<Execute>, errors::ConnectorError> {
let response: moneris::RefundResponse = res
.response
.parse_struct("moneris RefundResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/moneris.rs" role="context" start="683" end="700">
fn build_request(
&self,
req: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Post)
.url(&types::RefundExecuteType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::RefundExecuteType::get_headers(
self, req, connectors,
)?)
.set_body(types::RefundExecuteType::get_request_body(
self, req, connectors,
)?)
.build();
Ok(Some(request))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/moneris.rs" role="context" start="608" end="624">
fn build_request(
&self,
req: &PaymentsCancelRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsVoidType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsVoidType::get_headers(self, req, connectors)?)
.set_body(types::PaymentsVoidType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/novalnet.rs<|crate|> hyperswitch_connectors<|connector|> novalnet anchor=get_url kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/novalnet.rs" role="context" start="727" end="734">
fn get_url(
&self,
_req: &PaymentsCancelRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let endpoint = self.base_url(connectors);
Ok(format!("{}/transaction/cancel", endpoint))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/novalnet.rs" role="context" start="726" end="726">
fn get_headers(
&self,
req: &PaymentsCancelRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
&self,
_req: &PaymentsCancelRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let endpoint = self.base_url(connectors);
Ok(format!("{}/transaction/cancel", endpoint))
}
fn get_request_body(
&self,
req: &PaymentsCancelRouterData,
_connectors: &Connectors,
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/novalnet.rs" role="context" start="745" end="761">
fn build_request(
&self,
req: &PaymentsCancelRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsVoidType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsVoidType::get_headers(self, req, connectors)?)
.set_body(types::PaymentsVoidType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/novalnet.rs" role="context" start="736" end="743">
fn get_request_body(
&self,
req: &PaymentsCancelRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let connector_req = novalnet::NovalnetCancelRequest::try_from(req)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/novalnet.rs" role="context" start="723" end="725">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/novalnet.rs" role="context" start="715" end="721">
fn get_headers(
&self,
req: &PaymentsCancelRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/novalnet.rs" role="context" start="504" end="522">
fn build_request(
&self,
req: &PaymentsCaptureRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsCaptureType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsCaptureType::get_headers(
self, req, connectors,
)?)
.set_body(types::PaymentsCaptureType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/novalnet.rs" role="context" start="668" end="684">
fn build_request(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::RefundSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::RefundSyncType::get_headers(self, req, connectors)?)
.set_body(types::RefundSyncType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/stripebilling.rs<|crate|> hyperswitch_connectors<|connector|> stripebilling anchor=get_headers kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/stripebilling.rs" role="context" start="671" end="677">
fn get_headers(
&self,
req: &recovery_router_data_types::RevenueRecoveryRecordBackRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/stripebilling.rs" role="context" start="670" end="670">
use common_utils::{
errors::CustomResult,
ext_traits::BytesExt,
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, StringMinorUnit, StringMinorUnitForConnector},
};
use hyperswitch_domain_models::{
router_flow_types::revenue_recovery as recovery_router_flows,
router_request_types::revenue_recovery as recovery_request_types,
router_response_types::revenue_recovery as recovery_response_types,
types as recovery_router_data_types,
};
use hyperswitch_interfaces::{
api::{
self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorSpecifications,
ConnectorValidation,
},
configs::Connectors,
errors,
events::connector_api_logs::ConnectorEvent,
types::{self, Response},
webhooks,
};
use masking::ExposeInterface;
use masking::{Mask, PeekInterface};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/stripebilling.rs" role="context" start="683" end="704">
fn get_url(
&self,
req: &recovery_router_data_types::RevenueRecoveryRecordBackRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let invoice_id = req
.request
.merchant_reference_id
.get_string_repr()
.to_string();
match req.request.attempt_status {
common_enums::AttemptStatus::Charged => Ok(format!(
"{}/v1/invoices/{invoice_id}/pay?paid_out_of_band=true",
self.base_url(connectors),
)),
common_enums::AttemptStatus::Failure => Ok(format!(
"{}/v1/invoices/{invoice_id}/void",
self.base_url(connectors),
)),
_ => Err(errors::ConnectorError::FailedToObtainIntegrationUrl.into()),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/stripebilling.rs" role="context" start="679" end="681">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/stripebilling.rs" role="context" start="654" end="660">
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/stripebilling.rs" role="context" start="626" end="652">
fn handle_response(
&self,
data: &recovery_router_data_types::BillingConnectorPaymentsSyncRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<
recovery_router_data_types::BillingConnectorPaymentsSyncRouterData,
errors::ConnectorError,
> {
let response: stripebilling::StripebillingRecoveryDetailsData = res
.response
.parse_struct::<stripebilling::StripebillingRecoveryDetailsData>(
"StripebillingRecoveryDetailsData",
)
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
recovery_router_data_types::BillingConnectorPaymentsSyncRouterData::try_from(
ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
},
)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/stripebilling.rs" role="context" start="301" end="314">
fn build_request(
&self,
req: &PaymentsSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&types::PaymentsSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsSyncType::get_headers(self, req, connectors)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/stripebilling.rs" role="context" start="373" end="391">
fn build_request(
&self,
req: &PaymentsCaptureRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsCaptureType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsCaptureType::get_headers(
self, req, connectors,
)?)
.set_body(types::PaymentsCaptureType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/recurly.rs<|crate|> hyperswitch_connectors<|connector|> recurly anchor=get_headers kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/recurly.rs" role="context" start="691" end="697">
fn get_headers(
&self,
req: &recovery_router_data_types::RevenueRecoveryRecordBackRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/recurly.rs" role="context" start="690" end="690">
use common_utils::{
consts,
errors::CustomResult,
ext_traits::BytesExt,
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, StringMinorUnit, StringMinorUnitForConnector},
};
use hyperswitch_domain_models::{
revenue_recovery, router_flow_types::revenue_recovery as recovery_router_flows,
router_request_types::revenue_recovery as recovery_request_types,
router_response_types::revenue_recovery as recovery_response_types,
types as recovery_router_data_types,
};
use hyperswitch_interfaces::{
api::{
self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorSpecifications,
ConnectorValidation,
},
configs::Connectors,
errors,
events::connector_api_logs::ConnectorEvent,
types::{self, Response},
webhooks,
};
use masking::{Mask, PeekInterface};
use crate::connectors::recurly::transformers::{RecurlyRecordStatus, RecurlyRecoveryDetailsData};
use crate::{
connectors::recurly::transformers::RecurlyWebhookBody, constants::headers,
types::ResponseRouterData, utils,
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/recurly.rs" role="context" start="722" end="724">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/recurly.rs" role="context" start="698" end="720">
fn get_url(
&self,
req: &recovery_router_data_types::RevenueRecoveryRecordBackRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let invoice_id = req
.request
.merchant_reference_id
.get_string_repr()
.to_string();
let status = RecurlyRecordStatus::try_from(req.request.attempt_status)?;
let status_endpoint = match status {
RecurlyRecordStatus::Success => STATUS_SUCCESSFUL_ENDPOINT,
RecurlyRecordStatus::Failure => STATUS_FAILED_ENDPOINT,
};
Ok(format!(
"{}/invoices/{invoice_id}/{status_endpoint}",
self.base_url(connectors)
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/recurly.rs" role="context" start="674" end="680">
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/recurly.rs" role="context" start="648" end="672">
fn handle_response(
&self,
data: &recovery_router_data_types::BillingConnectorPaymentsSyncRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<
recovery_router_data_types::BillingConnectorPaymentsSyncRouterData,
errors::ConnectorError,
> {
let response: RecurlyRecoveryDetailsData = res
.response
.parse_struct::<RecurlyRecoveryDetailsData>("RecurlyRecoveryDetailsData")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
recovery_router_data_types::BillingConnectorPaymentsSyncRouterData::try_from(
ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
},
)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/recurly.rs" role="context" start="397" end="415">
fn build_request(
&self,
req: &PaymentsCaptureRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsCaptureType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsCaptureType::get_headers(
self, req, connectors,
)?)
.set_body(types::PaymentsCaptureType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/recurly.rs" role="context" start="254" end="274">
fn build_request(
&self,
req: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsAuthorizeType::get_url(
self, req, connectors,
)?)
.attach_default_headers()
.headers(types::PaymentsAuthorizeType::get_headers(
self, req, connectors,
)?)
.set_body(types::PaymentsAuthorizeType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/jpmorgan.rs<|crate|> hyperswitch_connectors<|connector|> jpmorgan anchor=get_url kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/jpmorgan.rs" role="context" start="739" end="746">
fn get_url(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let tid = req.request.connector_transaction_id.clone();
Ok(format!("{}/refunds/{}", self.base_url(connectors), tid))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/jpmorgan.rs" role="context" start="738" end="738">
use common_utils::{
errors::CustomResult,
ext_traits::BytesExt,
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, MinorUnit, MinorUnitForConnector},
};
use hyperswitch_domain_models::{
router_data::{AccessToken, ErrorResponse, RouterData},
router_flow_types::{
access_token_auth::AccessTokenAuth,
payments::{Authorize, Capture, PSync, PaymentMethodToken, Session, SetupMandate, Void},
refunds::{Execute, RSync},
},
router_request_types::{
AccessTokenRequestData, PaymentMethodTokenizationData, PaymentsAuthorizeData,
PaymentsCancelData, PaymentsCaptureData, PaymentsSessionData, PaymentsSyncData,
RefundsData, SetupMandateRequestData,
},
router_response_types::{
ConnectorInfo, PaymentMethodDetails, PaymentsResponseData, RefundsResponseData,
SupportedPaymentMethods, SupportedPaymentMethodsExt,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsSyncRouterData, RefundSyncRouterData, RefundsRouterData,
},
};
use hyperswitch_interfaces::{
api::{
self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorSpecifications,
ConnectorValidation,
},
configs::Connectors,
consts, errors,
events::connector_api_logs::ConnectorEvent,
types::{self, RefreshTokenType, Response},
webhooks,
};
use transformers::{self as jpmorgan, JpmorganErrorResponse};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/jpmorgan.rs" role="context" start="765" end="782">
fn handle_response(
&self,
data: &RefundSyncRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundSyncRouterData, errors::ConnectorError> {
let response: jpmorgan::JpmorganRefundSyncResponse = res
.response
.parse_struct("jpmorgan RefundSyncResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/jpmorgan.rs" role="context" start="747" end="763">
fn build_request(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&types::RefundSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::RefundSyncType::get_headers(self, req, connectors)?)
.set_body(types::RefundSyncType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/jpmorgan.rs" role="context" start="736" end="738">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/jpmorgan.rs" role="context" start="728" end="734">
fn get_headers(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/jpmorgan.rs" role="context" start="679" end="697">
fn build_request(
&self,
req: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::RefundExecuteType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::RefundExecuteType::get_headers(
self, req, connectors,
)?)
.set_body(types::RefundExecuteType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/jpmorgan.rs" role="context" start="440" end="458">
fn build_request(
&self,
req: &PaymentsCaptureRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsCaptureType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsCaptureType::get_headers(
self, req, connectors,
)?)
.set_body(types::PaymentsCaptureType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/moneris.rs<|crate|> hyperswitch_connectors<|connector|> moneris anchor=get_url kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/moneris.rs" role="context" start="743" end="750">
fn get_url(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let refund_id = req.request.get_connector_refund_id()?;
Ok(format!("{}/refunds/{refund_id}", self.base_url(connectors)))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/moneris.rs" role="context" start="742" end="742">
fn get_headers(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let refund_id = req.request.get_connector_refund_id()?;
Ok(format!("{}/refunds/{refund_id}", self.base_url(connectors)))
}
fn build_request(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/moneris.rs" role="context" start="770" end="787">
fn handle_response(
&self,
data: &RefundSyncRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundSyncRouterData, errors::ConnectorError> {
let response: moneris::RefundResponse = res
.response
.parse_struct("moneris RefundSyncResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/moneris.rs" role="context" start="752" end="768">
fn build_request(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&types::RefundSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::RefundSyncType::get_headers(self, req, connectors)?)
.set_body(types::RefundSyncType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/moneris.rs" role="context" start="739" end="741">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/moneris.rs" role="context" start="731" end="737">
fn get_headers(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/moneris.rs" role="context" start="608" end="624">
fn build_request(
&self,
req: &PaymentsCancelRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsVoidType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsVoidType::get_headers(self, req, connectors)?)
.set_body(types::PaymentsVoidType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/noon.rs<|crate|> hyperswitch_connectors<|connector|> noon anchor=get_url kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/noon.rs" role="context" start="750" end="760">
fn get_url(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}payment/v1/order/getbyreference/{}",
self.base_url(connectors),
req.connector_request_reference_id
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/noon.rs" role="context" start="749" end="749">
fn get_headers(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}payment/v1/order/getbyreference/{}",
self.base_url(connectors),
req.connector_request_reference_id
))
}
fn build_request(
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/noon.rs" role="context" start="777" end="797">
fn handle_response(
&self,
data: &RefundSyncRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundSyncRouterData, errors::ConnectorError> {
let response: noon::RefundSyncResponse = res
.response
.parse_struct("noon RefundSyncResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/noon.rs" role="context" start="762" end="775">
fn build_request(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&RefundSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(RefundSyncType::get_headers(self, req, connectors)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/noon.rs" role="context" start="746" end="748">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/noon.rs" role="context" start="738" end="744">
fn get_headers(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/noon.rs" role="context" start="460" end="476">
fn build_request(
&self,
req: &PaymentsCaptureRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&PaymentsCaptureType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(PaymentsCaptureType::get_headers(self, req, connectors)?)
.set_body(PaymentsCaptureType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/tsys.rs<|crate|> hyperswitch_connectors<|connector|> tsys anchor=get_request_body kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/tsys.rs" role="context" start="569" end="576">
fn get_request_body(
&self,
req: &RefundSyncRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let connector_req = tsys::TsysSyncRequest::try_from(req)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/tsys.rs" role="context" start="568" end="568">
fn get_url(
&self,
_req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}servlets/transnox_api_server",
self.base_url(connectors),
))
}
fn get_request_body(
&self,
req: &RefundSyncRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let connector_req = tsys::TsysSyncRequest::try_from(req)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
fn build_request(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/tsys.rs" role="context" start="594" end="613">
fn handle_response(
&self,
data: &RefundSyncRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundSyncRouterData, errors::ConnectorError> {
let response: tsys::TsysSyncResponse = res
.response
.parse_struct("tsys RefundSyncResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/tsys.rs" role="context" start="578" end="592">
fn build_request(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&RefundSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(RefundSyncType::get_headers(self, req, connectors)?)
.set_body(RefundSyncType::get_request_body(self, req, connectors)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/tsys.rs" role="context" start="558" end="567">
fn get_url(
&self,
_req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}servlets/transnox_api_server",
self.base_url(connectors),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/tsys.rs" role="context" start="554" end="556">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/tsys.rs" role="context" start="251" end="265">
fn build_request(
&self,
req: &PaymentsSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&PaymentsSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(PaymentsSyncType::get_headers(self, req, connectors)?)
.set_body(PaymentsSyncType::get_request_body(self, req, connectors)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/tsys.rs" role="context" start="500" end="513">
fn build_request(
&self,
req: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Post)
.url(&RefundExecuteType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(RefundExecuteType::get_headers(self, req, connectors)?)
.set_body(RefundExecuteType::get_request_body(self, req, connectors)?)
.build();
Ok(Some(request))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/tsys.rs" role="context" start="56" end="60">
pub fn new() -> &'static Self {
&Self {
amount_converter: &StringMinorUnitForConnector,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/tsys/transformers.rs" role="context" start="356" end="358">
pub struct TsysSyncRequest {
search_transaction: TsysSearchTransactionRequest,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/fiserv.rs<|crate|> hyperswitch_connectors<|connector|> fiserv anchor=get_request_body kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiserv.rs" role="context" start="725" end="732">
fn get_request_body(
&self,
req: &RefundSyncRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let connector_req = fiserv::FiservSyncRequest::try_from(req)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiserv.rs" role="context" start="724" end="724">
use common_utils::{
errors::CustomResult,
ext_traits::BytesExt,
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, FloatMajorUnit, FloatMajorUnitForConnector},
};
use hyperswitch_domain_models::{
router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::{
access_token_auth::AccessTokenAuth,
payments::{Authorize, Capture, PSync, PaymentMethodToken, Session, SetupMandate, Void},
refunds::{Execute, RSync},
},
router_request_types::{
AccessTokenRequestData, PaymentMethodTokenizationData, PaymentsAuthorizeData,
PaymentsCancelData, PaymentsCaptureData, PaymentsSessionData, PaymentsSyncData,
RefundsData, SetupMandateRequestData,
},
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsSyncRouterData, RefundSyncRouterData, RefundsRouterData,
},
};
use hyperswitch_interfaces::{
api::{
self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorSpecifications,
ConnectorValidation,
},
configs::Connectors,
consts, errors,
events::connector_api_logs::ConnectorEvent,
types, webhooks,
};
use transformers as fiserv;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiserv.rs" role="context" start="753" end="773">
fn handle_response(
&self,
data: &RefundSyncRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: types::Response,
) -> CustomResult<RefundSyncRouterData, errors::ConnectorError> {
router_env::logger::debug!(target: "router::connector::fiserv", response=?res);
let response: fiserv::FiservSyncResponse = res
.response
.parse_struct("Fiserv Refund Response")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiserv.rs" role="context" start="734" end="751">
fn build_request(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let request = Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::RefundSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::RefundSyncType::get_headers(self, req, connectors)?)
.set_body(types::RefundSyncType::get_request_body(
self, req, connectors,
)?)
.build(),
);
Ok(request)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiserv.rs" role="context" start="714" end="723">
fn get_url(
&self,
_req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}ch/payments/v1/transaction-inquiry",
connectors.fiserv.base_url
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiserv.rs" role="context" start="710" end="712">
fn get_content_type(&self) -> &'static str {
"application/json"
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiserv.rs" role="context" start="559" end="581">
fn build_request(
&self,
req: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let request = Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsAuthorizeType::get_url(
self, req, connectors,
)?)
.attach_default_headers()
.headers(types::PaymentsAuthorizeType::get_headers(
self, req, connectors,
)?)
.set_body(types::PaymentsAuthorizeType::get_request_body(
self, req, connectors,
)?)
.build(),
);
Ok(request)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiserv.rs" role="context" start="450" end="469">
fn build_request(
&self,
req: &PaymentsCaptureRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let request = Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsCaptureType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsCaptureType::get_headers(
self, req, connectors,
)?)
.set_body(types::PaymentsCaptureType::get_request_body(
self, req, connectors,
)?)
.build(),
);
Ok(request)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiserv.rs" role="context" start="58" end="62">
pub fn new() -> &'static Self {
&Self {
amount_converter: &FloatMajorUnitForConnector,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiserv/transformers.rs" role="context" start="503" end="506">
pub struct FiservSyncRequest {
merchant_details: MerchantDetails,
reference_transaction_details: ReferenceTransactionDetails,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/billwerk.rs<|crate|> hyperswitch_connectors<|connector|> billwerk anchor=get_url kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/billwerk.rs" role="context" start="721" end="731">
fn get_url(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let refund_id = req.request.get_connector_refund_id()?;
Ok(format!(
"{}v1/refund/{refund_id}",
self.base_url(connectors)
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/billwerk.rs" role="context" start="720" end="720">
fn get_headers(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let refund_id = req.request.get_connector_refund_id()?;
Ok(format!(
"{}v1/refund/{refund_id}",
self.base_url(connectors)
))
}
fn build_request(
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/billwerk.rs" role="context" start="751" end="768">
fn handle_response(
&self,
data: &RefundSyncRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundSyncRouterData, errors::ConnectorError> {
let response: billwerk::RefundResponse = res
.response
.parse_struct("billwerk RefundSyncResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/billwerk.rs" role="context" start="733" end="749">
fn build_request(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&types::RefundSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::RefundSyncType::get_headers(self, req, connectors)?)
.set_body(types::RefundSyncType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/billwerk.rs" role="context" start="717" end="719">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/billwerk.rs" role="context" start="709" end="715">
fn get_headers(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/billwerk.rs" role="context" start="309" end="329">
fn build_request(
&self,
req: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsAuthorizeType::get_url(
self, req, connectors,
)?)
.attach_default_headers()
.headers(types::PaymentsAuthorizeType::get_headers(
self, req, connectors,
)?)
.set_body(types::PaymentsAuthorizeType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/bankofamerica.rs<|crate|> hyperswitch_connectors<|connector|> bankofamerica anchor=get_url kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bankofamerica.rs" role="context" start="995" end="1005">
fn get_url(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let refund_id = req.request.get_connector_refund_id()?;
Ok(format!(
"{}tss/v2/transactions/{refund_id}",
self.base_url(connectors)
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bankofamerica.rs" role="context" start="994" end="994">
) -> CustomResult<Vec<(String, Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_http_method(&self) -> Method {
Method::Get
}
fn get_url(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let refund_id = req.request.get_connector_refund_id()?;
Ok(format!(
"{}tss/v2/transactions/{refund_id}",
self.base_url(connectors)
))
}
fn build_request(
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bankofamerica.rs" role="context" start="1022" end="1039">
fn handle_response(
&self,
data: &RefundSyncRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundSyncRouterData, errors::ConnectorError> {
let response: bankofamerica::BankOfAmericaRsyncResponse = res
.response
.parse_struct("bankofamerica RefundSyncResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bankofamerica.rs" role="context" start="1007" end="1020">
fn build_request(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&RefundSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(RefundSyncType::get_headers(self, req, connectors)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bankofamerica.rs" role="context" start="991" end="993">
fn get_http_method(&self) -> Method {
Method::Get
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bankofamerica.rs" role="context" start="987" end="989">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bankofamerica.rs" role="context" start="818" end="832">
fn build_request(
&self,
req: &PaymentsCancelRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&PaymentsVoidType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(PaymentsVoidType::get_headers(self, req, connectors)?)
.set_body(PaymentsVoidType::get_request_body(self, req, connectors)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bankofamerica.rs" role="context" start="933" end="946">
fn build_request(
&self,
req: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Post)
.url(&RefundExecuteType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(RefundExecuteType::get_headers(self, req, connectors)?)
.set_body(RefundExecuteType::get_request_body(self, req, connectors)?)
.build();
Ok(Some(request))
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/payu.rs<|crate|> hyperswitch_connectors<|connector|> payu anchor=get_url kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payu.rs" role="context" start="714" end="726">
fn get_url(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}{}{}{}",
self.base_url(connectors),
"api/v2_1/orders/",
req.request.connector_transaction_id,
"/refunds"
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payu.rs" role="context" start="713" end="713">
fn get_headers(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}{}{}{}",
self.base_url(connectors),
"api/v2_1/orders/",
req.request.connector_transaction_id,
"/refunds"
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payu.rs" role="context" start="743" end="761">
fn handle_response(
&self,
data: &RefundSyncRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundSyncRouterData, errors::ConnectorError> {
let response: payu::RefundSyncResponse =
res.response
.parse_struct("payu RefundResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payu.rs" role="context" start="728" end="741">
fn build_request(
&self,
req: &RefundsRouterData<RSync>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&RefundSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(RefundSyncType::get_headers(self, req, connectors)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payu.rs" role="context" start="710" end="712">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payu.rs" role="context" start="702" end="708">
fn get_headers(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payu.rs" role="context" start="657" end="670">
fn build_request(
&self,
req: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Post)
.url(&RefundExecuteType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(RefundExecuteType::get_headers(self, req, connectors)?)
.set_body(RefundExecuteType::get_request_body(self, req, connectors)?)
.build();
Ok(Some(request))
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/hipay.rs<|crate|> hyperswitch_connectors<|connector|> hipay anchor=get_url kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/hipay.rs" role="context" start="688" end="699">
fn get_url(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let connector_payment_id = req.request.connector_transaction_id.clone();
Ok(format!(
"{}v3/transaction/{}",
connectors.hipay.third_base_url.clone(),
connector_payment_id
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/hipay.rs" role="context" start="687" end="687">
use common_utils::{
consts::BASE64_ENGINE,
errors::{self as common_errors, CustomResult},
ext_traits::BytesExt,
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, StringMajorUnit, StringMajorUnitForConnector},
};
use hyperswitch_domain_models::{
router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::{
access_token_auth::AccessTokenAuth,
payments::{Authorize, Capture, PSync, PaymentMethodToken, Session, SetupMandate, Void},
refunds::{Execute, RSync},
},
router_request_types::{
AccessTokenRequestData, PaymentMethodTokenizationData, PaymentsAuthorizeData,
PaymentsCancelData, PaymentsCaptureData, PaymentsSessionData, PaymentsSyncData,
RefundsData, SetupMandateRequestData,
},
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsSyncRouterData, RefundSyncRouterData, RefundsRouterData, TokenizationRouterData,
},
};
use hyperswitch_interfaces::{
api::{
self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorSpecifications,
ConnectorValidation,
},
configs::Connectors,
errors,
events::connector_api_logs::ConnectorEvent,
types::{self, Response, TokenizationType},
webhooks,
};
use transformers as hipay;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/hipay.rs" role="context" start="719" end="736">
fn handle_response(
&self,
data: &RefundSyncRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundSyncRouterData, errors::ConnectorError> {
let response: hipay::RefundResponse = res
.response
.parse_struct("hipay RefundResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/hipay.rs" role="context" start="701" end="717">
fn build_request(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&types::RefundSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::RefundSyncType::get_headers(self, req, connectors)?)
.set_body(types::RefundSyncType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/hipay.rs" role="context" start="680" end="686">
fn get_headers(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/hipay.rs" role="context" start="670" end="676">
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/hipay.rs" role="context" start="394" end="407">
fn build_request(
&self,
req: &PaymentsSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&types::PaymentsSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsSyncType::get_headers(self, req, connectors)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/hipay.rs" role="context" start="134" end="147">
fn build_request(
&self,
req: &TokenizationRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&TokenizationType::get_url(self, req, connectors)?)
.headers(TokenizationType::get_headers(self, req, connectors)?)
.set_body(TokenizationType::get_request_body(self, req, connectors)?)
.build(),
))
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/boku.rs<|crate|> hyperswitch_connectors<|connector|> boku anchor=get_url kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/boku.rs" role="context" start="580" end="591">
fn get_url(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let boku_url = get_country_url(
req.connector_meta_data.clone(),
self.base_url(connectors).to_string(),
)?;
Ok(format!("{boku_url}/billing/3.0/query-refund"))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/boku.rs" role="context" start="579" end="579">
use common_utils::{
errors::CustomResult,
ext_traits::{BytesExt, OptionExt, XmlExt},
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, MinorUnit, MinorUnitForConnector},
};
use hyperswitch_domain_models::{
router_data::{AccessToken, ErrorResponse, RouterData},
router_flow_types::{
access_token_auth::AccessTokenAuth,
payments::{Authorize, Capture, PSync, PaymentMethodToken, Session, SetupMandate, Void},
refunds::{Execute, RSync},
},
router_request_types::{
AccessTokenRequestData, PaymentMethodTokenizationData, PaymentsAuthorizeData,
PaymentsCancelData, PaymentsCaptureData, PaymentsSessionData, PaymentsSyncData,
RefundsData, SetupMandateRequestData,
},
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{
PaymentsAuthorizeRouterData, PaymentsCaptureRouterData, PaymentsSyncRouterData,
RefundSyncRouterData, RefundsRouterData,
},
};
use hyperswitch_interfaces::{
api::{
self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorSpecifications,
ConnectorValidation,
},
configs::Connectors,
consts::NO_ERROR_CODE,
errors,
events::connector_api_logs::ConnectorEvent,
types::{self, Response},
webhooks::{IncomingWebhook, IncomingWebhookRequestDetails},
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/boku.rs" role="context" start="602" end="618">
fn build_request(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&types::RefundSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::RefundSyncType::get_headers(self, req, connectors)?)
.set_body(types::RefundSyncType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/boku.rs" role="context" start="593" end="600">
fn get_request_body(
&self,
req: &RefundSyncRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let connector_req = boku::BokuRsyncRequest::try_from(req)?;
Ok(RequestContent::Xml(Box::new(connector_req)))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/boku.rs" role="context" start="576" end="578">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/boku.rs" role="context" start="568" end="574">
fn get_headers(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/boku.rs" role="context" start="91" end="129">
fn build_headers(
&self,
req: &RouterData<Flow, Request, Response>,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
let connector_auth = boku::BokuAuthType::try_from(&req.connector_auth_type)?;
let boku_url = Self::get_url(self, req, connectors)?;
let content_type = Self::common_get_content_type(self);
let connector_method = Self::get_http_method(self);
let timestamp = OffsetDateTime::now_utc().unix_timestamp_nanos() / 1_000_000;
let secret_key = boku::BokuAuthType::try_from(&req.connector_auth_type)?
.key_id
.expose();
let to_sign = format!(
"{} {}\nContent-Type: {}\n{}",
connector_method, boku_url, &content_type, timestamp
);
let key = hmac::Key::new(hmac::HMAC_SHA256, secret_key.as_bytes());
let tag = hmac::sign(&key, to_sign.as_bytes());
let signature = hex::encode(tag);
let auth_val = format!("2/HMAC_SHA256(H+SHA256(E)) timestamp={timestamp}, signature={signature} signed-headers=Content-Type, key-id={}", connector_auth.key_id.peek());
let header = vec![
(headers::CONTENT_TYPE.to_string(), content_type.into()),
(headers::AUTHORIZATION.to_string(), auth_val.into_masked()),
];
Ok(header)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/boku.rs" role="context" start="672" end="681">
fn get_country_url(
meta_data: Option<Secret<serde_json::Value, WithType>>,
base_url: String,
) -> Result<String, Report<errors::ConnectorError>> {
let conn_meta_data: boku::BokuMetaData = meta_data
.parse_value("Object")
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
Ok(base_url.replace('$', &conn_meta_data.country.to_lowercase()))
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu.rs<|crate|> hyperswitch_connectors<|connector|> fiuu anchor=get_request_body kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu.rs" role="context" start="741" end="749">
fn get_request_body(
&self,
req: &RefundSyncRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let connector_req = build_form_from_struct(fiuu::FiuuRefundSyncRequest::try_from(req)?)
.change_context(errors::ConnectorError::ParsingFailed)?;
Ok(RequestContent::FormData(connector_req))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu.rs" role="context" start="740" end="740">
}
impl ConnectorIntegration<RSync, RefundsData, RefundsResponseData> for Fiuu {
fn get_url(
&self,
_req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let base_url = connectors.fiuu.secondary_base_url.clone();
Ok(format!("{}RMS/API/refundAPI/q_by_txn.php", base_url))
}
fn get_request_body(
&self,
req: &RefundSyncRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let connector_req = build_form_from_struct(fiuu::FiuuRefundSyncRequest::try_from(req)?)
.change_context(errors::ConnectorError::ParsingFailed)?;
Ok(RequestContent::FormData(connector_req))
}
fn build_request(
&self,
req: &RefundSyncRouterData,
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu.rs" role="context" start="768" end="785">
fn handle_response(
&self,
data: &RefundSyncRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundSyncRouterData, errors::ConnectorError> {
let response: fiuu::FiuuRefundSyncResponse = res
.response
.parse_struct("fiuu FiuuRefundSyncResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu.rs" role="context" start="751" end="766">
fn build_request(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::RefundSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.set_body(types::RefundSyncType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu.rs" role="context" start="732" end="739">
fn get_url(
&self,
_req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let base_url = connectors.fiuu.secondary_base_url.clone();
Ok(format!("{}RMS/API/refundAPI/q_by_txn.php", base_url))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu.rs" role="context" start="722" end="728">
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu.rs" role="context" start="687" end="701">
fn build_request(
&self,
req: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Post)
.url(&types::RefundExecuteType::get_url(self, req, connectors)?)
.attach_default_headers()
.set_body(types::RefundExecuteType::get_request_body(
self, req, connectors,
)?)
.build();
Ok(Some(request))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu.rs" role="context" start="244" end="267">
pub fn build_form_from_struct<T: Serialize>(data: T) -> Result<Form, common_errors::ParsingError> {
let mut form = Form::new();
let serialized = serde_json::to_value(&data).map_err(|e| {
router_env::logger::error!("Error serializing data to JSON value: {:?}", e);
common_errors::ParsingError::EncodeError("json-value")
})?;
let serialized_object = serialized.as_object().ok_or_else(|| {
router_env::logger::error!("Error: Expected JSON object but got something else");
common_errors::ParsingError::EncodeError("Expected object")
})?;
for (key, values) in serialized_object {
let value = match values {
Value::String(s) => s.clone(),
Value::Number(n) => n.to_string(),
Value::Bool(b) => b.to_string(),
Value::Array(_) | Value::Object(_) | Value::Null => {
router_env::logger::error!(serialization_error =? "Form Construction Failed.");
"".to_string()
}
};
form = form.text(key.clone(), value.clone());
}
Ok(form)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu/transformers.rs" role="context" start="1643" end="1649">
pub struct FiuuRefundSyncRequest {
#[serde(rename = "TxnID")]
txn_id: String,
#[serde(rename = "MerchantID")]
merchant_id: Secret<String>,
signature: Secret<String>,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/bambora.rs<|crate|> hyperswitch_connectors<|connector|> bambora anchor=get_url kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bambora.rs" role="context" start="739" end="751">
fn get_url(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let _connector_payment_id = req.request.connector_transaction_id.clone();
let connector_refund_id = req.request.get_connector_refund_id()?;
Ok(format!(
"{}/v1/payments/{}",
self.base_url(connectors),
connector_refund_id
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bambora.rs" role="context" start="738" end="738">
fn get_headers(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let _connector_payment_id = req.request.connector_transaction_id.clone();
let connector_refund_id = req.request.get_connector_refund_id()?;
Ok(format!(
"{}/v1/payments/{}",
self.base_url(connectors),
connector_refund_id
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bambora.rs" role="context" start="768" end="788">
fn handle_response(
&self,
data: &RefundSyncRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundSyncRouterData, errors::ConnectorError> {
let response: bambora::RefundResponse = res
.response
.parse_struct("bambora RefundResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bambora.rs" role="context" start="753" end="766">
fn build_request(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&types::RefundSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::RefundSyncType::get_headers(self, req, connectors)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bambora.rs" role="context" start="735" end="737">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bambora.rs" role="context" start="727" end="733">
fn get_headers(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bambora.rs" role="context" start="473" end="487">
fn build_request(
&self,
req: &PaymentsCaptureRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&PaymentsCaptureType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(PaymentsCaptureType::get_headers(self, req, connectors)?)
.set_body(self.get_request_body(req, connectors)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bambora.rs" role="context" start="218" end="234">
fn build_request(
&self,
req: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&PaymentsAuthorizeType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(PaymentsAuthorizeType::get_headers(self, req, connectors)?)
.set_body(PaymentsAuthorizeType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/elavon.rs<|crate|> hyperswitch_connectors<|connector|> elavon anchor=get_request_body kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/elavon.rs" role="context" start="503" end="513">
fn get_request_body(
&self,
req: &RefundSyncRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let connector_req = elavon::SyncRequest::try_from(req)?;
router_env::logger::info!(raw_connector_request=?connector_req);
Ok(RequestContent::FormUrlEncoded(Box::new(struct_to_xml(
&connector_req,
)?)))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/elavon.rs" role="context" start="502" end="502">
use common_utils::{
errors::CustomResult,
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, StringMajorUnit, StringMajorUnitForConnector},
};
use hyperswitch_domain_models::{
router_data::{AccessToken, ErrorResponse, RouterData},
router_flow_types::{
access_token_auth::AccessTokenAuth,
payments::{Authorize, Capture, PSync, PaymentMethodToken, Session, SetupMandate, Void},
refunds::{Execute, RSync},
},
router_request_types::{
AccessTokenRequestData, PaymentMethodTokenizationData, PaymentsAuthorizeData,
PaymentsCancelData, PaymentsCaptureData, PaymentsSessionData, PaymentsSyncData,
RefundsData, SetupMandateRequestData,
},
router_response_types::{
ConnectorInfo, PaymentMethodDetails, PaymentsResponseData, RefundsResponseData,
SupportedPaymentMethods, SupportedPaymentMethodsExt,
},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsSyncRouterData, RefundSyncRouterData, RefundsRouterData,
},
};
use hyperswitch_interfaces::{
api::{
self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorSpecifications,
ConnectorValidation,
},
configs::Connectors,
errors,
events::connector_api_logs::ConnectorEvent,
types::{self, Response},
webhooks,
};
use transformers as elavon;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/elavon.rs" role="context" start="533" end="547">
fn handle_response(
&self,
data: &RefundSyncRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundSyncRouterData, errors::ConnectorError> {
let response: elavon::ElavonSyncResponse = utils::deserialize_xml_to_struct(&res.response)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/elavon.rs" role="context" start="515" end="531">
fn build_request(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::RefundSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::RefundSyncType::get_headers(self, req, connectors)?)
.set_body(types::RefundSyncType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/elavon.rs" role="context" start="496" end="502">
fn get_url(
&self,
_req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}processxml.do", self.base_url(connectors)))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/elavon.rs" role="context" start="492" end="494">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/elavon.rs" role="context" start="438" end="455">
fn build_request(
&self,
req: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Post)
.url(&types::RefundExecuteType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::RefundExecuteType::get_headers(
self, req, connectors,
)?)
.set_body(types::RefundExecuteType::get_request_body(
self, req, connectors,
)?)
.build();
Ok(Some(request))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/elavon.rs" role="context" start="342" end="360">
fn build_request(
&self,
req: &PaymentsCaptureRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsCaptureType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsCaptureType::get_headers(
self, req, connectors,
)?)
.set_body(types::PaymentsCaptureType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/elavon.rs" role="context" start="70" end="74">
pub fn new() -> &'static Self {
&Self {
amount_converter: &StringMajorUnitForConnector,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/elavon.rs" role="context" start="49" end="63">
pub fn struct_to_xml<T: Serialize>(
item: &T,
) -> Result<HashMap<String, Secret<String, WithoutType>>, errors::ConnectorError> {
let xml_content = quick_xml::se::to_string_with_root("txn", &item).map_err(|e| {
router_env::logger::error!("Error serializing Struct: {:?}", e);
errors::ConnectorError::ResponseDeserializationFailed
})?;
let mut result = HashMap::new();
result.insert(
"xmldata".to_string(),
Secret::<_, WithoutType>::new(xml_content),
);
Ok(result)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/elavon/transformers.rs" role="context" start="310" end="316">
pub struct SyncRequest {
pub ssl_transaction_type: TransactionType,
pub ssl_account_id: Secret<String>,
pub ssl_user_id: Secret<String>,
pub ssl_pin: Secret<String>,
pub ssl_txn_id: String,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/paybox.rs<|crate|> hyperswitch_connectors<|connector|> paybox anchor=get_request_body kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paybox.rs" role="context" start="620" end="634">
fn get_request_body(
&self,
req: &PaymentsCompleteAuthorizeRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let amount = convert_amount(
self.amount_converter,
req.request.minor_amount,
req.request.currency,
)?;
let connector_router_data = paybox::PayboxRouterData::from((amount, req));
let connector_req = paybox::PaymentsRequest::try_from(&connector_router_data)?;
Ok(RequestContent::FormUrlEncoded(Box::new(connector_req)))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paybox.rs" role="context" start="619" end="619">
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
&self,
_req: &PaymentsCompleteAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(self.base_url(connectors).to_string())
}
fn get_request_body(
&self,
req: &PaymentsCompleteAuthorizeRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let amount = convert_amount(
self.amount_converter,
req.request.minor_amount,
req.request.currency,
)?;
let connector_router_data = paybox::PayboxRouterData::from((amount, req));
let connector_req = paybox::PaymentsRequest::try_from(&connector_router_data)?;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paybox.rs" role="context" start="655" end="670">
fn handle_response(
&self,
data: &PaymentsCompleteAuthorizeRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsCompleteAuthorizeRouterData, errors::ConnectorError> {
let response: paybox::TransactionResponse =
paybox::parse_url_encoded_to_struct(res.response)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paybox.rs" role="context" start="635" end="654">
fn build_request(
&self,
req: &PaymentsCompleteAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsCompleteAuthorizeType::get_url(
self, req, connectors,
)?)
.headers(types::PaymentsCompleteAuthorizeType::get_headers(
self, req, connectors,
)?)
.set_body(types::PaymentsCompleteAuthorizeType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paybox.rs" role="context" start="613" end="619">
fn get_url(
&self,
_req: &PaymentsCompleteAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(self.base_url(connectors).to_string())
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paybox.rs" role="context" start="610" end="612">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paybox.rs" role="context" start="227" end="244">
fn build_request(
&self,
req: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsAuthorizeType::get_url(
self, req, connectors,
)?)
.attach_default_headers()
.set_body(types::PaymentsAuthorizeType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paybox.rs" role="context" start="63" end="67">
pub fn new() -> &'static Self {
&Self {
amount_converter: &MinorUnitForConnector,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="72" end="83">
pub struct PaymentsRequest {
ds_merchant_emv3ds: Option<EmvThreedsData>,
ds_merchant_transactiontype: RedsysTransactionType,
ds_merchant_currency: String,
ds_merchant_pan: cards::CardNumber,
ds_merchant_merchantcode: Secret<String>,
ds_merchant_terminal: Secret<String>,
ds_merchant_order: String,
ds_merchant_amount: StringMinorUnit,
ds_merchant_expirydate: Secret<String>,
ds_merchant_cvv2: Secret<String>,
}
<file_sep path="hyperswitch/crates/api_models/src/payments.rs" role="context" start="849" end="1160">
pub struct PaymentsRequest {
/// The payment amount. Amount for the payment in the lowest denomination of the currency, (i.e) in cents for USD denomination, in yen for JPY denomination etc. E.g., Pass 100 to charge $1.00 and 1 for 1¥ since ¥ is a zero-decimal currency. Read more about [the Decimal and Non-Decimal Currencies](https://github.com/juspay/hyperswitch/wiki/Decimal-and-Non%E2%80%90Decimal-Currencies)
#[schema(value_type = Option<u64>, example = 6540)]
#[serde(default, deserialize_with = "amount::deserialize_option")]
#[mandatory_in(PaymentsCreateRequest = u64)]
// Makes the field mandatory in PaymentsCreateRequest
pub amount: Option<Amount>,
/// Total tax amount applicable to the order
#[schema(value_type = Option<i64>, example = 6540)]
pub order_tax_amount: Option<MinorUnit>,
/// The three letter ISO currency code in uppercase. Eg: 'USD' to charge US Dollars
#[schema(example = "USD", value_type = Option<Currency>)]
#[mandatory_in(PaymentsCreateRequest = Currency)]
pub currency: Option<api_enums::Currency>,
/// The Amount to be captured / debited from the users payment method. It shall be in lowest denomination of the currency. (i.e) in cents for USD denomination, in paisa for INR denomination etc., If not provided, the default amount_to_capture will be the payment amount. Also, it must be less than or equal to the original payment account.
#[schema(value_type = Option<i64>, example = 6540)]
pub amount_to_capture: Option<MinorUnit>,
/// The shipping cost for the payment. This is required for tax calculation in some regions.
#[schema(value_type = Option<i64>, example = 6540)]
pub shipping_cost: Option<MinorUnit>,
/// Unique identifier for the payment. This ensures idempotency for multiple payments
/// that have been done by a single merchant. The value for this field can be specified in the request, it will be auto generated otherwise and returned in the API response.
#[schema(
value_type = Option<String>,
min_length = 30,
max_length = 30,
example = "pay_mbabizu24mvu3mela5njyhpit4"
)]
#[serde(default, deserialize_with = "payment_id_type::deserialize_option")]
pub payment_id: Option<PaymentIdType>,
/// This is an identifier for the merchant account. This is inferred from the API key
/// provided during the request
#[schema(max_length = 255, example = "merchant_1668273825", value_type = Option<String>)]
#[remove_in(PaymentsUpdateRequest, PaymentsCreateRequest, PaymentsConfirmRequest)]
pub merchant_id: Option<id_type::MerchantId>,
/// Details of the routing configuration for that payment
#[schema(value_type = Option<StraightThroughAlgorithm>, example = json!({
"type": "single",
"data": {"connector": "stripe", "merchant_connector_id": "mca_123"}
}))]
pub routing: Option<serde_json::Value>,
/// This allows to manually select a connector with which the payment can go through.
#[schema(value_type = Option<Vec<Connector>>, max_length = 255, example = json!(["stripe", "adyen"]))]
pub connector: Option<Vec<api_enums::Connector>>,
#[schema(value_type = Option<CaptureMethod>, example = "automatic")]
pub capture_method: Option<api_enums::CaptureMethod>,
#[schema(value_type = Option<AuthenticationType>, example = "no_three_ds", default = "three_ds")]
pub authentication_type: Option<api_enums::AuthenticationType>,
/// The billing details of the payment. This address will be used for invoicing.
pub billing: Option<Address>,
/// A timestamp (ISO 8601 code) that determines when the payment should be captured.
/// Providing this field will automatically set `capture` to true
#[schema(example = "2022-09-10T10:11:12Z")]
#[serde(default, with = "common_utils::custom_serde::iso8601::option")]
#[remove_in(PaymentsUpdateRequest, PaymentsCreateRequest, PaymentsConfirmRequest)]
pub capture_on: Option<PrimitiveDateTime>,
/// Whether to confirm the payment (if applicable). It can be used to completely process a payment by attaching a payment method, setting `confirm=true` and `capture_method = automatic` in the *Payments/Create API* request itself.
#[schema(default = false, example = true)]
pub confirm: Option<bool>,
/// Passing this object creates a new customer or attaches an existing customer to the payment
pub customer: Option<CustomerDetails>,
/// The identifier for the customer
#[schema(value_type = Option<String>, max_length = 64, min_length = 1, example = "cus_y3oqhf46pyzuxjbcn2giaqnb44")]
pub customer_id: Option<id_type::CustomerId>,
/// The customer's email address.
/// This field will be deprecated soon, use the customer object instead
#[schema(max_length = 255, value_type = Option<String>, example = "johntest@test.com", deprecated)]
#[remove_in(PaymentsUpdateRequest, PaymentsCreateRequest, PaymentsConfirmRequest)]
pub email: Option<Email>,
/// The customer's name.
/// This field will be deprecated soon, use the customer object instead.
#[schema(value_type = Option<String>, max_length = 255, example = "John Test", deprecated)]
#[remove_in(PaymentsUpdateRequest, PaymentsCreateRequest, PaymentsConfirmRequest)]
pub name: Option<Secret<String>>,
/// The customer's phone number
/// This field will be deprecated soon, use the customer object instead
#[schema(value_type = Option<String>, max_length = 255, example = "9123456789", deprecated)]
#[remove_in(PaymentsUpdateRequest, PaymentsCreateRequest, PaymentsConfirmRequest)]
pub phone: Option<Secret<String>>,
/// The country code for the customer phone number
/// This field will be deprecated soon, use the customer object instead
#[schema(max_length = 255, example = "+1", deprecated)]
#[remove_in(PaymentsUpdateRequest, PaymentsCreateRequest, PaymentsConfirmRequest)]
pub phone_country_code: Option<String>,
/// Set to true to indicate that the customer is not in your checkout flow during this payment, and therefore is unable to authenticate. This parameter is intended for scenarios where you collect card details and charge them later. When making a recurring payment by passing a mandate_id, this parameter is mandatory
#[schema(example = true)]
pub off_session: Option<bool>,
/// A description for the payment
#[schema(example = "It's my first payment request")]
pub description: Option<String>,
/// The URL to which you want the user to be redirected after the completion of the payment operation
#[schema(value_type = Option<String>, example = "https://hyperswitch.io")]
pub return_url: Option<Url>,
#[schema(value_type = Option<FutureUsage>, example = "off_session")]
pub setup_future_usage: Option<api_enums::FutureUsage>,
#[schema(example = "bank_transfer")]
#[serde(with = "payment_method_data_serde", default)]
pub payment_method_data: Option<PaymentMethodDataRequest>,
#[schema(value_type = Option<PaymentMethod>, example = "card")]
pub payment_method: Option<api_enums::PaymentMethod>,
/// As Hyperswitch tokenises the sensitive details about the payments method, it provides the payment_token as a reference to a stored payment method, ensuring that the sensitive details are not exposed in any manner.
#[schema(example = "187282ab-40ef-47a9-9206-5099ba31e432")]
pub payment_token: Option<String>,
/// This is used along with the payment_token field while collecting during saved card payments. This field will be deprecated soon, use the payment_method_data.card_token object instead
#[schema(value_type = Option<String>, deprecated)]
#[remove_in(PaymentsUpdateRequest, PaymentsCreateRequest, PaymentsConfirmRequest)]
pub card_cvc: Option<Secret<String>>,
/// The shipping address for the payment
pub shipping: Option<Address>,
/// For non-card charges, you can use this value as the complete description that appears on your customers’ statements. Must contain at least one letter, maximum 22 characters.
#[schema(max_length = 255, example = "Hyperswitch Router")]
pub statement_descriptor_name: Option<String>,
/// Provides information about a card payment that customers see on their statements. Concatenated with the prefix (shortened descriptor) or statement descriptor that’s set on the account to form the complete statement descriptor. Maximum 22 characters for the concatenated descriptor.
#[schema(max_length = 255, example = "Payment for shoes purchase")]
pub statement_descriptor_suffix: Option<String>,
/// Use this object to capture the details about the different products for which the payment is being made. The sum of amount across different products here should be equal to the overall payment amount
#[schema(value_type = Option<Vec<OrderDetailsWithAmount>>, example = r#"[{
"product_name": "Apple iPhone 16",
"quantity": 1,
"amount" : 69000
"product_img_link" : "https://dummy-img-link.com"
}]"#)]
pub order_details: Option<Vec<OrderDetailsWithAmount>>,
/// It's a token used for client side verification.
#[schema(example = "pay_U42c409qyHwOkWo3vK60_secret_el9ksDkiB8hi6j9N78yo")]
#[remove_in(PaymentsUpdateRequest, PaymentsCreateRequest)]
pub client_secret: Option<String>,
/// Passing this object during payments creates a mandate. The mandate_type sub object is passed by the server.
pub mandate_data: Option<MandateData>,
/// This "CustomerAcceptance" object is passed during Payments-Confirm request, it enlists the type, time, and mode of acceptance properties related to an acceptance done by the customer. The customer_acceptance sub object is usually passed by the SDK or client.
#[schema(value_type = Option<CustomerAcceptance>)]
pub customer_acceptance: Option<CustomerAcceptance>,
/// A unique identifier to link the payment to a mandate. To do Recurring payments after a mandate has been created, pass the mandate_id instead of payment_method_data
#[schema(max_length = 255, example = "mandate_iwer89rnjef349dni3")]
#[remove_in(PaymentsUpdateRequest)]
pub mandate_id: Option<String>,
/// Additional details required by 3DS 2.0
#[schema(value_type = Option<BrowserInformation>, example = r#"{
"user_agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.110 Safari/537.36",
"accept_header": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8",
"language": "nl-NL",
"color_depth": 24,
"screen_height": 723,
"screen_width": 1536,
"time_zone": 0,
"java_enabled": true,
"java_script_enabled":true
}"#)]
pub browser_info: Option<serde_json::Value>,
/// To indicate the type of payment experience that the payment method would go through
#[schema(value_type = Option<PaymentExperience>, example = "redirect_to_url")]
pub payment_experience: Option<api_enums::PaymentExperience>,
/// Can be used to specify the Payment Method Type
#[schema(value_type = Option<PaymentMethodType>, example = "google_pay")]
pub payment_method_type: Option<api_enums::PaymentMethodType>,
/// Business country of the merchant for this payment.
/// To be deprecated soon. Pass the profile_id instead
#[schema(value_type = Option<CountryAlpha2>, example = "US")]
#[remove_in(PaymentsUpdateRequest, PaymentsConfirmRequest)]
pub business_country: Option<api_enums::CountryAlpha2>,
/// Business label of the merchant for this payment.
/// To be deprecated soon. Pass the profile_id instead
#[schema(example = "food")]
#[remove_in(PaymentsUpdateRequest, PaymentsConfirmRequest)]
pub business_label: Option<String>,
#[schema(value_type = Option<MerchantConnectorDetailsWrap>)]
pub merchant_connector_details: Option<admin::MerchantConnectorDetailsWrap>,
/// Use this parameter to restrict the Payment Method Types to show for a given PaymentIntent
#[schema(value_type = Option<Vec<PaymentMethodType>>)]
pub allowed_payment_method_types: Option<Vec<api_enums::PaymentMethodType>>,
/// Business sub label for the payment
#[remove_in(PaymentsUpdateRequest, PaymentsConfirmRequest, PaymentsCreateRequest)]
pub business_sub_label: Option<String>,
/// Denotes the retry action
#[schema(value_type = Option<RetryAction>)]
#[remove_in(PaymentsCreateRequest)]
pub retry_action: Option<api_enums::RetryAction>,
/// You can specify up to 50 keys, with key names up to 40 characters long and values up to 500 characters long. Metadata is useful for storing additional, structured information on an object.
#[schema(value_type = Option<Object>, example = r#"{ "udf1": "some-value", "udf2": "some-value" }"#)]
pub metadata: Option<serde_json::Value>,
/// Some connectors like Apple pay, Airwallex and Noon might require some additional information, find specific details in the child attributes below.
pub connector_metadata: Option<ConnectorMetadata>,
/// Additional data that might be required by hyperswitch based on the requested features by the merchants.
#[remove_in(PaymentsUpdateRequest, PaymentsCreateRequest, PaymentsConfirmRequest)]
pub feature_metadata: Option<FeatureMetadata>,
/// Whether to generate the payment link for this payment or not (if applicable)
#[schema(default = false, example = true)]
pub payment_link: Option<bool>,
#[schema(value_type = Option<PaymentCreatePaymentLinkConfig>)]
pub payment_link_config: Option<PaymentCreatePaymentLinkConfig>,
/// Custom payment link config id set at business profile, send only if business_specific_configs is configured
pub payment_link_config_id: Option<String>,
/// The business profile to be used for this payment, if not passed the default business profile associated with the merchant account will be used. It is mandatory in case multiple business profiles have been set up.
#[remove_in(PaymentsUpdateRequest, PaymentsConfirmRequest)]
#[schema(value_type = Option<String>)]
pub profile_id: Option<id_type::ProfileId>,
#[remove_in(PaymentsConfirmRequest)]
#[schema(value_type = Option<RequestSurchargeDetails>)]
pub surcharge_details: Option<RequestSurchargeDetails>,
/// The type of the payment that differentiates between normal and various types of mandate payments
#[schema(value_type = Option<PaymentType>)]
pub payment_type: Option<api_enums::PaymentType>,
///Request an incremental authorization, i.e., increase the authorized amount on a confirmed payment before you capture it.
pub request_incremental_authorization: Option<bool>,
///Will be used to expire client secret after certain amount of time to be supplied in seconds
///(900) for 15 mins
#[schema(example = 900)]
pub session_expiry: Option<u32>,
/// Additional data related to some frm(Fraud Risk Management) connectors
#[schema(value_type = Option<Object>, example = r#"{ "coverage_request" : "fraud", "fulfillment_method" : "delivery" }"#)]
pub frm_metadata: Option<pii::SecretSerdeValue>,
/// Whether to perform external authentication (if applicable)
#[schema(example = true)]
pub request_external_three_ds_authentication: Option<bool>,
/// Details required for recurring payment
pub recurring_details: Option<RecurringDetails>,
/// Fee information to be charged on the payment being collected
#[schema(value_type = Option<SplitPaymentsRequest>)]
pub split_payments: Option<common_types::payments::SplitPaymentsRequest>,
/// Optional boolean value to extent authorization period of this payment
///
/// capture method must be manual or manual_multiple
#[schema(value_type = Option<bool>, default = false)]
pub request_extended_authorization: Option<RequestExtendedAuthorizationBool>,
/// Merchant's identifier for the payment/invoice. This will be sent to the connector
/// if the connector provides support to accept multiple reference ids.
/// In case the connector supports only one reference id, Hyperswitch's Payment ID will be sent as reference.
#[schema(
value_type = Option<String>,
max_length = 255,
example = "Custom_Order_id_123"
)]
pub merchant_order_reference_id: Option<String>,
/// Whether to calculate tax for this payment intent
pub skip_external_tax_calculation: Option<bool>,
/// Choose what kind of sca exemption is required for this payment
#[schema(value_type = Option<ScaExemptionType>)]
pub psd2_sca_exemption_type: Option<api_enums::ScaExemptionType>,
/// Service details for click to pay external authentication
#[schema(value_type = Option<CtpServiceDetails>)]
pub ctp_service_details: Option<CtpServiceDetails>,
/// Indicates if 3ds challenge is forced
pub force_3ds_challenge: Option<bool>,
/// Indicates if 3DS method data was successfully completed or not
pub threeds_method_comp_ind: Option<ThreeDsCompletionIndicator>,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/paybox.rs<|crate|> hyperswitch_connectors<|connector|> paybox anchor=get_request_body kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paybox.rs" role="context" start="620" end="634">
fn get_request_body(
&self,
req: &PaymentsCompleteAuthorizeRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let amount = convert_amount(
self.amount_converter,
req.request.minor_amount,
req.request.currency,
)?;
let connector_router_data = paybox::PayboxRouterData::from((amount, req));
let connector_req = paybox::PaymentsRequest::try_from(&connector_router_data)?;
Ok(RequestContent::FormUrlEncoded(Box::new(connector_req)))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paybox.rs" role="context" start="619" end="619">
self.build_headers(req, connectors)
}
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
&self,
_req: &PaymentsCompleteAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(self.base_url(connectors).to_string())
}
fn get_request_body(
&self,
req: &PaymentsCompleteAuthorizeRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let amount = convert_amount(
self.amount_converter,
req.request.minor_amount,
req.request.currency,
)?;
let connector_router_data = paybox::PayboxRouterData::from((amount, req));
let connector_req = paybox::PaymentsRequest::try_from(&connector_router_data)?;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paybox.rs" role="context" start="655" end="670">
fn handle_response(
&self,
data: &PaymentsCompleteAuthorizeRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<PaymentsCompleteAuthorizeRouterData, errors::ConnectorError> {
let response: paybox::TransactionResponse =
paybox::parse_url_encoded_to_struct(res.response)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paybox.rs" role="context" start="635" end="654">
fn build_request(
&self,
req: &PaymentsCompleteAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsCompleteAuthorizeType::get_url(
self, req, connectors,
)?)
.headers(types::PaymentsCompleteAuthorizeType::get_headers(
self, req, connectors,
)?)
.set_body(types::PaymentsCompleteAuthorizeType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paybox.rs" role="context" start="613" end="619">
fn get_url(
&self,
_req: &PaymentsCompleteAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(self.base_url(connectors).to_string())
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paybox.rs" role="context" start="610" end="612">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paybox.rs" role="context" start="227" end="244">
fn build_request(
&self,
req: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsAuthorizeType::get_url(
self, req, connectors,
)?)
.attach_default_headers()
.set_body(types::PaymentsAuthorizeType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paybox.rs" role="context" start="63" end="67">
pub fn new() -> &'static Self {
&Self {
amount_converter: &MinorUnitForConnector,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/redsys/transformers.rs" role="context" start="72" end="83">
pub struct PaymentsRequest {
ds_merchant_emv3ds: Option<EmvThreedsData>,
ds_merchant_transactiontype: RedsysTransactionType,
ds_merchant_currency: String,
ds_merchant_pan: cards::CardNumber,
ds_merchant_merchantcode: Secret<String>,
ds_merchant_terminal: Secret<String>,
ds_merchant_order: String,
ds_merchant_amount: StringMinorUnit,
ds_merchant_expirydate: Secret<String>,
ds_merchant_cvv2: Secret<String>,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/globalpay.rs<|crate|> hyperswitch_connectors<|connector|> globalpay anchor=get_request_body kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globalpay.rs" role="context" start="808" end="822">
fn get_request_body(
&self,
req: &RefundsRouterData<Execute>,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let amount = convert_amount(
self.amount_converter,
req.request.minor_refund_amount,
req.request.currency,
)?;
let connector_router_data = requests::GlobalPayRouterData::from((amount, req));
let connector_req = requests::GlobalpayRefundRequest::try_from(&connector_router_data)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globalpay.rs" role="context" start="807" end="807">
fn get_url(
&self,
req: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}transactions/{}/refund",
self.base_url(connectors),
req.request.connector_transaction_id
))
}
fn get_request_body(
&self,
req: &RefundsRouterData<Execute>,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let amount = convert_amount(
self.amount_converter,
req.request.minor_refund_amount,
req.request.currency,
)?;
let connector_router_data = requests::GlobalPayRouterData::from((amount, req));
let connector_req = requests::GlobalpayRefundRequest::try_from(&connector_router_data)?;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globalpay.rs" role="context" start="839" end="859">
fn handle_response(
&self,
data: &RefundsRouterData<Execute>,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundsRouterData<Execute>, errors::ConnectorError> {
let response: GlobalpayPaymentsResponse = res
.response
.parse_struct("globalpay RefundResponse")
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globalpay.rs" role="context" start="824" end="837">
fn build_request(
&self,
req: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Post)
.url(&RefundExecuteType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(RefundExecuteType::get_headers(self, req, connectors)?)
.set_body(RefundExecuteType::get_request_body(self, req, connectors)?)
.build();
Ok(Some(request))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globalpay.rs" role="context" start="796" end="806">
fn get_url(
&self,
req: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}transactions/{}/refund",
self.base_url(connectors),
req.request.connector_transaction_id
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globalpay.rs" role="context" start="792" end="794">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globalpay.rs" role="context" start="730" end="746">
fn build_request(
&self,
req: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&PaymentsAuthorizeType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(PaymentsAuthorizeType::get_headers(self, req, connectors)?)
.set_body(PaymentsAuthorizeType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globalpay.rs" role="context" start="315" end="329">
fn build_request(
&self,
req: &RefreshTokenRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&RefreshTokenType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(RefreshTokenType::get_headers(self, req, connectors)?)
.set_body(RefreshTokenType::get_request_body(self, req, connectors)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globalpay.rs" role="context" start="74" end="78">
pub fn new() -> &'static Self {
&Self {
amount_converter: &StringMinorUnitForConnector,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/globalpay/requests.rs" role="context" start="6" end="9">
pub struct GlobalPayRouterData<T> {
pub amount: StringMinorUnit,
pub router_data: T,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/worldline.rs<|crate|> hyperswitch_connectors<|connector|> worldline anchor=get_url kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/worldline.rs" role="context" start="646" end="659">
fn get_url(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let refund_id = req.request.get_connector_refund_id()?;
let base_url = self.base_url(connectors);
let auth: worldline::WorldlineAuthType =
worldline::WorldlineAuthType::try_from(&req.connector_auth_type)?;
let merchant_account_id = auth.merchant_account_id.expose();
Ok(format!(
"{base_url}v1/{merchant_account_id}/refunds/{refund_id}/"
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/worldline.rs" role="context" start="645" end="645">
fn get_content_type(&self) -> &'static str {
""
}
fn get_headers(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
fn get_url(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let refund_id = req.request.get_connector_refund_id()?;
let base_url = self.base_url(connectors);
let auth: worldline::WorldlineAuthType =
worldline::WorldlineAuthType::try_from(&req.connector_auth_type)?;
let merchant_account_id = auth.merchant_account_id.expose();
Ok(format!(
"{base_url}v1/{merchant_account_id}/refunds/{refund_id}/"
))
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/worldline.rs" role="context" start="676" end="695">
fn handle_response(
&self,
data: &RefundSyncRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundSyncRouterData, errors::ConnectorError> {
logger::debug!(target: "router::connector::worldline", response=?res);
let response: worldline::RefundResponse = res
.response
.parse_struct("Worldline RefundResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/worldline.rs" role="context" start="661" end="674">
fn build_request(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(RefundSyncType::get_http_method(self))
.url(&RefundSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(RefundSyncType::get_headers(self, req, connectors)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/worldline.rs" role="context" start="638" end="644">
fn get_headers(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/worldline.rs" role="context" start="634" end="636">
fn get_content_type(&self) -> &'static str {
""
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/worldline.rs" role="context" start="234" end="247">
fn build_request(
&self,
req: &RouterData<Void, PaymentsCancelData, PaymentsResponseData>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(PaymentsVoidType::get_http_method(self))
.url(&PaymentsVoidType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(PaymentsVoidType::get_headers(self, req, connectors)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/worldline/transformers.rs" role="context" start="489" end="493">
pub struct WorldlineAuthType {
pub api_key: Secret<String>,
pub api_secret: Secret<String>,
pub merchant_account_id: Secret<String>,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/klarna.rs<|crate|> hyperswitch_connectors<|connector|> klarna anchor=build_region_specific_endpoint kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/klarna.rs" role="context" start="196" end="210">
fn build_region_specific_endpoint(
base_url: &str,
connector_metadata: &Option<common_utils::pii::SecretSerdeValue>,
) -> CustomResult<String, errors::ConnectorError> {
let klarna_metadata_object =
transformers::KlarnaConnectorMetadataObject::try_from(connector_metadata)?;
let klarna_region = klarna_metadata_object
.klarna_region
.ok_or(errors::ConnectorError::InvalidConnectorConfig {
config: "merchant_connector_account.metadata.klarna_region",
})
.map(String::from)?;
Ok(base_url.replace("{{klarna_region}}", &klarna_region))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/klarna.rs" role="context" start="195" end="195">
use common_utils::{
consts::BASE64_ENGINE,
errors::CustomResult,
ext_traits::BytesExt,
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, MinorUnit, MinorUnitForConnector},
};
use hyperswitch_interfaces::{
api::{
self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorSpecifications,
ConnectorValidation,
},
configs::Connectors,
consts::NO_ERROR_MESSAGE,
errors,
events::connector_api_logs::ConnectorEvent,
types::{self, Response},
webhooks::{IncomingWebhook, IncomingWebhookRequestDetails},
};
use transformers as klarna;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/klarna.rs" role="context" start="221" end="223">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/klarna.rs" role="context" start="213" end="219">
fn get_headers(
&self,
req: &PaymentsSessionRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/klarna.rs" role="context" start="179" end="193">
fn build_headers(
&self,
req: &RouterData<Flow, Request, Response>,
_connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
let mut header = vec![(
headers::CONTENT_TYPE.to_string(),
types::PaymentsAuthorizeType::get_content_type(self)
.to_string()
.into(),
)];
let mut api_key = self.get_auth_header(&req.connector_auth_type)?;
header.append(&mut api_key);
Ok(header)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/klarna.rs" role="context" start="137" end="152">
fn validate_connector_against_payment_request(
&self,
capture_method: Option<enums::CaptureMethod>,
_payment_method: enums::PaymentMethod,
_pmt: Option<enums::PaymentMethodType>,
) -> CustomResult<(), errors::ConnectorError> {
let capture_method = capture_method.unwrap_or_default();
match capture_method {
enums::CaptureMethod::Automatic
| enums::CaptureMethod::Manual
| enums::CaptureMethod::SequentialAutomatic => Ok(()),
enums::CaptureMethod::ManualMultiple | enums::CaptureMethod::Scheduled => Err(
construct_not_supported_error_report(capture_method, self.id()),
),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/klarna.rs" role="context" start="1116" end="1128">
fn get_url(
&self,
req: &PaymentsCancelRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let order_id = req.request.connector_transaction_id.clone();
let endpoint =
build_region_specific_endpoint(self.base_url(connectors), &req.connector_meta_data)?;
Ok(format!(
"{endpoint}ordermanagement/v1/orders/{order_id}/cancel"
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/klarna.rs" role="context" start="519" end="1036">
fn get_url(
&self,
req: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let payment_method_data = &req.request.payment_method_data;
let payment_experience = req
.request
.payment_experience
.as_ref()
.ok_or_else(missing_field_err("payment_experience"))?;
let payment_method_type = req
.request
.payment_method_type
.as_ref()
.ok_or_else(missing_field_err("payment_method_type"))?;
let endpoint =
build_region_specific_endpoint(self.base_url(connectors), &req.connector_meta_data)?;
match payment_method_data {
PaymentMethodData::PayLater(PayLaterData::KlarnaSdk { token }) => {
match (payment_experience, payment_method_type) {
(
common_enums::PaymentExperience::InvokeSdkClient,
common_enums::PaymentMethodType::Klarna,
) => Ok(format!(
"{endpoint}payments/v1/authorizations/{token}/order",
)),
#[cfg(feature = "v1")]
(
common_enums::PaymentExperience::DisplayQrCode
| common_enums::PaymentExperience::DisplayWaitScreen
| common_enums::PaymentExperience::InvokePaymentApp
| common_enums::PaymentExperience::InvokeSdkClient
| common_enums::PaymentExperience::LinkWallet
| common_enums::PaymentExperience::OneClick
| common_enums::PaymentExperience::RedirectToUrl
| common_enums::PaymentExperience::CollectOtp,
common_enums::PaymentMethodType::Ach
| common_enums::PaymentMethodType::Affirm
| common_enums::PaymentMethodType::AfterpayClearpay
| common_enums::PaymentMethodType::Alfamart
| common_enums::PaymentMethodType::AliPay
| common_enums::PaymentMethodType::AliPayHk
| common_enums::PaymentMethodType::Alma
| common_enums::PaymentMethodType::AmazonPay
| common_enums::PaymentMethodType::ApplePay
| common_enums::PaymentMethodType::Atome
| common_enums::PaymentMethodType::Bacs
| common_enums::PaymentMethodType::BancontactCard
| common_enums::PaymentMethodType::Becs
| common_enums::PaymentMethodType::Benefit
| common_enums::PaymentMethodType::Bizum
| common_enums::PaymentMethodType::Blik
| common_enums::PaymentMethodType::Boleto
| common_enums::PaymentMethodType::BcaBankTransfer
| common_enums::PaymentMethodType::BniVa
| common_enums::PaymentMethodType::BriVa
| common_enums::PaymentMethodType::CardRedirect
| common_enums::PaymentMethodType::CimbVa
| common_enums::PaymentMethodType::ClassicReward
| common_enums::PaymentMethodType::Credit
| common_enums::PaymentMethodType::CryptoCurrency
| common_enums::PaymentMethodType::Cashapp
| common_enums::PaymentMethodType::Dana
| common_enums::PaymentMethodType::DanamonVa
| common_enums::PaymentMethodType::Debit
| common_enums::PaymentMethodType::DirectCarrierBilling
| common_enums::PaymentMethodType::Efecty
| common_enums::PaymentMethodType::Eft
| common_enums::PaymentMethodType::Eps
| common_enums::PaymentMethodType::Evoucher
| common_enums::PaymentMethodType::Giropay
| common_enums::PaymentMethodType::Givex
| common_enums::PaymentMethodType::GooglePay
| common_enums::PaymentMethodType::GoPay
| common_enums::PaymentMethodType::Gcash
| common_enums::PaymentMethodType::Ideal
| common_enums::PaymentMethodType::Interac
| common_enums::PaymentMethodType::Indomaret
| common_enums::PaymentMethodType::Klarna
| common_enums::PaymentMethodType::KakaoPay
| common_enums::PaymentMethodType::MandiriVa
| common_enums::PaymentMethodType::Knet
| common_enums::PaymentMethodType::MbWay
| common_enums::PaymentMethodType::MobilePay
| common_enums::PaymentMethodType::Momo
| common_enums::PaymentMethodType::MomoAtm
| common_enums::PaymentMethodType::Multibanco
| common_enums::PaymentMethodType::LocalBankRedirect
| common_enums::PaymentMethodType::OnlineBankingThailand
| common_enums::PaymentMethodType::OnlineBankingCzechRepublic
| common_enums::PaymentMethodType::OnlineBankingFinland
| common_enums::PaymentMethodType::OnlineBankingFpx
| common_enums::PaymentMethodType::OnlineBankingPoland
| common_enums::PaymentMethodType::OnlineBankingSlovakia
| common_enums::PaymentMethodType::Oxxo
| common_enums::PaymentMethodType::PagoEfectivo
| common_enums::PaymentMethodType::PermataBankTransfer
| common_enums::PaymentMethodType::OpenBankingUk
| common_enums::PaymentMethodType::PayBright
| common_enums::PaymentMethodType::Paypal
| common_enums::PaymentMethodType::Paze
| common_enums::PaymentMethodType::Pix
| common_enums::PaymentMethodType::PaySafeCard
| common_enums::PaymentMethodType::Przelewy24
| common_enums::PaymentMethodType::Pse
| common_enums::PaymentMethodType::RedCompra
| common_enums::PaymentMethodType::RedPagos
| common_enums::PaymentMethodType::SamsungPay
| common_enums::PaymentMethodType::Sepa
| common_enums::PaymentMethodType::SepaBankTransfer
| common_enums::PaymentMethodType::Sofort
| common_enums::PaymentMethodType::Swish
| common_enums::PaymentMethodType::TouchNGo
| common_enums::PaymentMethodType::Trustly
| common_enums::PaymentMethodType::Twint
| common_enums::PaymentMethodType::UpiCollect
| common_enums::PaymentMethodType::UpiIntent
| common_enums::PaymentMethodType::Venmo
| common_enums::PaymentMethodType::Vipps
| common_enums::PaymentMethodType::Walley
| common_enums::PaymentMethodType::WeChatPay
| common_enums::PaymentMethodType::SevenEleven
| common_enums::PaymentMethodType::Lawson
| common_enums::PaymentMethodType::LocalBankTransfer
| common_enums::PaymentMethodType::InstantBankTransfer
| common_enums::PaymentMethodType::MiniStop
| common_enums::PaymentMethodType::FamilyMart
| common_enums::PaymentMethodType::Seicomart
| common_enums::PaymentMethodType::PayEasy
| common_enums::PaymentMethodType::Mifinity
| common_enums::PaymentMethodType::Fps
| common_enums::PaymentMethodType::DuitNow
| common_enums::PaymentMethodType::PromptPay
| common_enums::PaymentMethodType::VietQr
| common_enums::PaymentMethodType::OpenBankingPIS,
) => Err(error_stack::report!(errors::ConnectorError::NotSupported {
message: payment_method_type.to_string(),
connector: "klarna",
})),
#[cfg(feature = "v2")]
(
common_enums::PaymentExperience::DisplayQrCode
| common_enums::PaymentExperience::DisplayWaitScreen
| common_enums::PaymentExperience::InvokePaymentApp
| common_enums::PaymentExperience::InvokeSdkClient
| common_enums::PaymentExperience::LinkWallet
| common_enums::PaymentExperience::OneClick
| common_enums::PaymentExperience::RedirectToUrl
| common_enums::PaymentExperience::CollectOtp,
common_enums::PaymentMethodType::Ach
| common_enums::PaymentMethodType::Affirm
| common_enums::PaymentMethodType::AfterpayClearpay
| common_enums::PaymentMethodType::Alfamart
| common_enums::PaymentMethodType::AliPay
| common_enums::PaymentMethodType::AliPayHk
| common_enums::PaymentMethodType::Alma
| common_enums::PaymentMethodType::AmazonPay
| common_enums::PaymentMethodType::ApplePay
| common_enums::PaymentMethodType::Atome
| common_enums::PaymentMethodType::Bacs
| common_enums::PaymentMethodType::BancontactCard
| common_enums::PaymentMethodType::Becs
| common_enums::PaymentMethodType::Benefit
| common_enums::PaymentMethodType::Bizum
| common_enums::PaymentMethodType::Blik
| common_enums::PaymentMethodType::Boleto
| common_enums::PaymentMethodType::BcaBankTransfer
| common_enums::PaymentMethodType::BniVa
| common_enums::PaymentMethodType::BriVa
| common_enums::PaymentMethodType::CardRedirect
| common_enums::PaymentMethodType::CimbVa
| common_enums::PaymentMethodType::ClassicReward
| common_enums::PaymentMethodType::Credit
| common_enums::PaymentMethodType::Card
| common_enums::PaymentMethodType::CryptoCurrency
| common_enums::PaymentMethodType::Cashapp
| common_enums::PaymentMethodType::Dana
| common_enums::PaymentMethodType::DanamonVa
| common_enums::PaymentMethodType::Debit
| common_enums::PaymentMethodType::DirectCarrierBilling
| common_enums::PaymentMethodType::Efecty
| common_enums::PaymentMethodType::Eft
| common_enums::PaymentMethodType::Eps
| common_enums::PaymentMethodType::Evoucher
| common_enums::PaymentMethodType::Giropay
| common_enums::PaymentMethodType::Givex
| common_enums::PaymentMethodType::GooglePay
| common_enums::PaymentMethodType::GoPay
| common_enums::PaymentMethodType::Gcash
| common_enums::PaymentMethodType::Ideal
| common_enums::PaymentMethodType::Interac
| common_enums::PaymentMethodType::Indomaret
| common_enums::PaymentMethodType::Klarna
| common_enums::PaymentMethodType::KakaoPay
| common_enums::PaymentMethodType::MandiriVa
| common_enums::PaymentMethodType::Knet
| common_enums::PaymentMethodType::MbWay
| common_enums::PaymentMethodType::MobilePay
| common_enums::PaymentMethodType::Momo
| common_enums::PaymentMethodType::MomoAtm
| common_enums::PaymentMethodType::Multibanco
| common_enums::PaymentMethodType::LocalBankRedirect
| common_enums::PaymentMethodType::OnlineBankingThailand
| common_enums::PaymentMethodType::OnlineBankingCzechRepublic
| common_enums::PaymentMethodType::OnlineBankingFinland
| common_enums::PaymentMethodType::OnlineBankingFpx
| common_enums::PaymentMethodType::OnlineBankingPoland
| common_enums::PaymentMethodType::OnlineBankingSlovakia
| common_enums::PaymentMethodType::Oxxo
| common_enums::PaymentMethodType::PagoEfectivo
| common_enums::PaymentMethodType::PermataBankTransfer
| common_enums::PaymentMethodType::OpenBankingUk
| common_enums::PaymentMethodType::PayBright
| common_enums::PaymentMethodType::Paypal
| common_enums::PaymentMethodType::Paze
| common_enums::PaymentMethodType::Pix
| common_enums::PaymentMethodType::PaySafeCard
| common_enums::PaymentMethodType::Przelewy24
| common_enums::PaymentMethodType::Pse
| common_enums::PaymentMethodType::RedCompra
| common_enums::PaymentMethodType::RedPagos
| common_enums::PaymentMethodType::SamsungPay
| common_enums::PaymentMethodType::Sepa
| common_enums::PaymentMethodType::SepaBankTransfer
| common_enums::PaymentMethodType::Sofort
| common_enums::PaymentMethodType::Swish
| common_enums::PaymentMethodType::TouchNGo
| common_enums::PaymentMethodType::Trustly
| common_enums::PaymentMethodType::Twint
| common_enums::PaymentMethodType::UpiCollect
| common_enums::PaymentMethodType::UpiIntent
| common_enums::PaymentMethodType::Venmo
| common_enums::PaymentMethodType::Vipps
| common_enums::PaymentMethodType::Walley
| common_enums::PaymentMethodType::WeChatPay
| common_enums::PaymentMethodType::SevenEleven
| common_enums::PaymentMethodType::Lawson
| common_enums::PaymentMethodType::LocalBankTransfer
| common_enums::PaymentMethodType::InstantBankTransfer
| common_enums::PaymentMethodType::MiniStop
| common_enums::PaymentMethodType::FamilyMart
| common_enums::PaymentMethodType::Seicomart
| common_enums::PaymentMethodType::PayEasy
| common_enums::PaymentMethodType::Mifinity
| common_enums::PaymentMethodType::Fps
| common_enums::PaymentMethodType::DuitNow
| common_enums::PaymentMethodType::PromptPay
| common_enums::PaymentMethodType::VietQr
| common_enums::PaymentMethodType::OpenBankingPIS,
) => Err(error_stack::report!(errors::ConnectorError::NotSupported {
message: payment_method_type.to_string(),
connector: "klarna",
})),
}
}
PaymentMethodData::PayLater(PayLaterData::KlarnaRedirect {}) => {
match (payment_experience, payment_method_type) {
(
common_enums::PaymentExperience::RedirectToUrl,
common_enums::PaymentMethodType::Klarna,
) => Ok(format!("{endpoint}checkout/v3/orders",)),
#[cfg(feature = "v1")]
(
common_enums::PaymentExperience::DisplayQrCode
| common_enums::PaymentExperience::DisplayWaitScreen
| common_enums::PaymentExperience::InvokePaymentApp
| common_enums::PaymentExperience::InvokeSdkClient
| common_enums::PaymentExperience::LinkWallet
| common_enums::PaymentExperience::OneClick
| common_enums::PaymentExperience::RedirectToUrl
| common_enums::PaymentExperience::CollectOtp,
common_enums::PaymentMethodType::Ach
| common_enums::PaymentMethodType::Affirm
| common_enums::PaymentMethodType::AfterpayClearpay
| common_enums::PaymentMethodType::Alfamart
| common_enums::PaymentMethodType::AliPay
| common_enums::PaymentMethodType::AliPayHk
| common_enums::PaymentMethodType::Alma
| common_enums::PaymentMethodType::AmazonPay
| common_enums::PaymentMethodType::ApplePay
| common_enums::PaymentMethodType::Atome
| common_enums::PaymentMethodType::Bacs
| common_enums::PaymentMethodType::BancontactCard
| common_enums::PaymentMethodType::Becs
| common_enums::PaymentMethodType::Benefit
| common_enums::PaymentMethodType::Bizum
| common_enums::PaymentMethodType::Blik
| common_enums::PaymentMethodType::Boleto
| common_enums::PaymentMethodType::BcaBankTransfer
| common_enums::PaymentMethodType::BniVa
| common_enums::PaymentMethodType::BriVa
| common_enums::PaymentMethodType::CardRedirect
| common_enums::PaymentMethodType::CimbVa
| common_enums::PaymentMethodType::ClassicReward
| common_enums::PaymentMethodType::Credit
| common_enums::PaymentMethodType::CryptoCurrency
| common_enums::PaymentMethodType::Cashapp
| common_enums::PaymentMethodType::Dana
| common_enums::PaymentMethodType::DanamonVa
| common_enums::PaymentMethodType::Debit
| common_enums::PaymentMethodType::DirectCarrierBilling
| common_enums::PaymentMethodType::Efecty
| common_enums::PaymentMethodType::Eft
| common_enums::PaymentMethodType::Eps
| common_enums::PaymentMethodType::Evoucher
| common_enums::PaymentMethodType::Giropay
| common_enums::PaymentMethodType::Givex
| common_enums::PaymentMethodType::GooglePay
| common_enums::PaymentMethodType::GoPay
| common_enums::PaymentMethodType::Gcash
| common_enums::PaymentMethodType::Ideal
| common_enums::PaymentMethodType::Interac
| common_enums::PaymentMethodType::Indomaret
| common_enums::PaymentMethodType::Klarna
| common_enums::PaymentMethodType::KakaoPay
| common_enums::PaymentMethodType::MandiriVa
| common_enums::PaymentMethodType::Knet
| common_enums::PaymentMethodType::MbWay
| common_enums::PaymentMethodType::MobilePay
| common_enums::PaymentMethodType::Momo
| common_enums::PaymentMethodType::MomoAtm
| common_enums::PaymentMethodType::Multibanco
| common_enums::PaymentMethodType::LocalBankRedirect
| common_enums::PaymentMethodType::OnlineBankingThailand
| common_enums::PaymentMethodType::OnlineBankingCzechRepublic
| common_enums::PaymentMethodType::OnlineBankingFinland
| common_enums::PaymentMethodType::OnlineBankingFpx
| common_enums::PaymentMethodType::OnlineBankingPoland
| common_enums::PaymentMethodType::OnlineBankingSlovakia
| common_enums::PaymentMethodType::Oxxo
| common_enums::PaymentMethodType::PagoEfectivo
| common_enums::PaymentMethodType::PermataBankTransfer
| common_enums::PaymentMethodType::OpenBankingUk
| common_enums::PaymentMethodType::PayBright
| common_enums::PaymentMethodType::Paypal
| common_enums::PaymentMethodType::Paze
| common_enums::PaymentMethodType::Pix
| common_enums::PaymentMethodType::PaySafeCard
| common_enums::PaymentMethodType::Przelewy24
| common_enums::PaymentMethodType::Pse
| common_enums::PaymentMethodType::RedCompra
| common_enums::PaymentMethodType::RedPagos
| common_enums::PaymentMethodType::SamsungPay
| common_enums::PaymentMethodType::Sepa
| common_enums::PaymentMethodType::SepaBankTransfer
| common_enums::PaymentMethodType::Sofort
| common_enums::PaymentMethodType::Swish
| common_enums::PaymentMethodType::TouchNGo
| common_enums::PaymentMethodType::Trustly
| common_enums::PaymentMethodType::Twint
| common_enums::PaymentMethodType::UpiCollect
| common_enums::PaymentMethodType::UpiIntent
| common_enums::PaymentMethodType::Venmo
| common_enums::PaymentMethodType::Vipps
| common_enums::PaymentMethodType::Walley
| common_enums::PaymentMethodType::WeChatPay
| common_enums::PaymentMethodType::SevenEleven
| common_enums::PaymentMethodType::Lawson
| common_enums::PaymentMethodType::LocalBankTransfer
| common_enums::PaymentMethodType::InstantBankTransfer
| common_enums::PaymentMethodType::MiniStop
| common_enums::PaymentMethodType::FamilyMart
| common_enums::PaymentMethodType::Seicomart
| common_enums::PaymentMethodType::PayEasy
| common_enums::PaymentMethodType::Mifinity
| common_enums::PaymentMethodType::Fps
| common_enums::PaymentMethodType::DuitNow
| common_enums::PaymentMethodType::PromptPay
| common_enums::PaymentMethodType::VietQr
| common_enums::PaymentMethodType::OpenBankingPIS,
) => Err(error_stack::report!(errors::ConnectorError::NotSupported {
message: payment_method_type.to_string(),
connector: "klarna",
})),
#[cfg(feature = "v2")]
(
common_enums::PaymentExperience::DisplayQrCode
| common_enums::PaymentExperience::DisplayWaitScreen
| common_enums::PaymentExperience::InvokePaymentApp
| common_enums::PaymentExperience::InvokeSdkClient
| common_enums::PaymentExperience::LinkWallet
| common_enums::PaymentExperience::OneClick
| common_enums::PaymentExperience::RedirectToUrl
| common_enums::PaymentExperience::CollectOtp,
common_enums::PaymentMethodType::Ach
| common_enums::PaymentMethodType::Affirm
| common_enums::PaymentMethodType::AfterpayClearpay
| common_enums::PaymentMethodType::Alfamart
| common_enums::PaymentMethodType::AliPay
| common_enums::PaymentMethodType::AliPayHk
| common_enums::PaymentMethodType::Alma
| common_enums::PaymentMethodType::AmazonPay
| common_enums::PaymentMethodType::ApplePay
| common_enums::PaymentMethodType::Atome
| common_enums::PaymentMethodType::Bacs
| common_enums::PaymentMethodType::BancontactCard
| common_enums::PaymentMethodType::Becs
| common_enums::PaymentMethodType::Benefit
| common_enums::PaymentMethodType::Bizum
| common_enums::PaymentMethodType::Blik
| common_enums::PaymentMethodType::Boleto
| common_enums::PaymentMethodType::BcaBankTransfer
| common_enums::PaymentMethodType::BniVa
| common_enums::PaymentMethodType::BriVa
| common_enums::PaymentMethodType::CardRedirect
| common_enums::PaymentMethodType::CimbVa
| common_enums::PaymentMethodType::ClassicReward
| common_enums::PaymentMethodType::Credit
| common_enums::PaymentMethodType::Card
| common_enums::PaymentMethodType::CryptoCurrency
| common_enums::PaymentMethodType::Cashapp
| common_enums::PaymentMethodType::Dana
| common_enums::PaymentMethodType::DanamonVa
| common_enums::PaymentMethodType::Debit
| common_enums::PaymentMethodType::DirectCarrierBilling
| common_enums::PaymentMethodType::Efecty
| common_enums::PaymentMethodType::Eft
| common_enums::PaymentMethodType::Eps
| common_enums::PaymentMethodType::Evoucher
| common_enums::PaymentMethodType::Giropay
| common_enums::PaymentMethodType::Givex
| common_enums::PaymentMethodType::GooglePay
| common_enums::PaymentMethodType::GoPay
| common_enums::PaymentMethodType::Gcash
| common_enums::PaymentMethodType::Ideal
| common_enums::PaymentMethodType::Interac
| common_enums::PaymentMethodType::Indomaret
| common_enums::PaymentMethodType::Klarna
| common_enums::PaymentMethodType::KakaoPay
| common_enums::PaymentMethodType::MandiriVa
| common_enums::PaymentMethodType::Knet
| common_enums::PaymentMethodType::MbWay
| common_enums::PaymentMethodType::MobilePay
| common_enums::PaymentMethodType::Momo
| common_enums::PaymentMethodType::MomoAtm
| common_enums::PaymentMethodType::Multibanco
| common_enums::PaymentMethodType::LocalBankRedirect
| common_enums::PaymentMethodType::OnlineBankingThailand
| common_enums::PaymentMethodType::OnlineBankingCzechRepublic
| common_enums::PaymentMethodType::OnlineBankingFinland
| common_enums::PaymentMethodType::OnlineBankingFpx
| common_enums::PaymentMethodType::OnlineBankingPoland
| common_enums::PaymentMethodType::OnlineBankingSlovakia
| common_enums::PaymentMethodType::Oxxo
| common_enums::PaymentMethodType::PagoEfectivo
| common_enums::PaymentMethodType::PermataBankTransfer
| common_enums::PaymentMethodType::OpenBankingUk
| common_enums::PaymentMethodType::PayBright
| common_enums::PaymentMethodType::Paypal
| common_enums::PaymentMethodType::Paze
| common_enums::PaymentMethodType::Pix
| common_enums::PaymentMethodType::PaySafeCard
| common_enums::PaymentMethodType::Przelewy24
| common_enums::PaymentMethodType::Pse
| common_enums::PaymentMethodType::RedCompra
| common_enums::PaymentMethodType::RedPagos
| common_enums::PaymentMethodType::SamsungPay
| common_enums::PaymentMethodType::Sepa
| common_enums::PaymentMethodType::SepaBankTransfer
| common_enums::PaymentMethodType::Sofort
| common_enums::PaymentMethodType::Swish
| common_enums::PaymentMethodType::TouchNGo
| common_enums::PaymentMethodType::Trustly
| common_enums::PaymentMethodType::Twint
| common_enums::PaymentMethodType::UpiCollect
| common_enums::PaymentMethodType::UpiIntent
| common_enums::PaymentMethodType::Venmo
| common_enums::PaymentMethodType::Vipps
| common_enums::PaymentMethodType::Walley
| common_enums::PaymentMethodType::WeChatPay
| common_enums::PaymentMethodType::SevenEleven
| common_enums::PaymentMethodType::Lawson
| common_enums::PaymentMethodType::LocalBankTransfer
| common_enums::PaymentMethodType::InstantBankTransfer
| common_enums::PaymentMethodType::MiniStop
| common_enums::PaymentMethodType::FamilyMart
| common_enums::PaymentMethodType::Seicomart
| common_enums::PaymentMethodType::PayEasy
| common_enums::PaymentMethodType::Mifinity
| common_enums::PaymentMethodType::Fps
| common_enums::PaymentMethodType::DuitNow
| common_enums::PaymentMethodType::PromptPay
| common_enums::PaymentMethodType::VietQr
| common_enums::PaymentMethodType::OpenBankingPIS,
) => Err(error_stack::report!(errors::ConnectorError::NotSupported {
message: payment_method_type.to_string(),
connector: "klarna",
})),
}
}
PaymentMethodData::Card(_)
| PaymentMethodData::CardRedirect(_)
| PaymentMethodData::Wallet(_)
| PaymentMethodData::PayLater(_)
| PaymentMethodData::BankRedirect(_)
| PaymentMethodData::BankDebit(_)
| PaymentMethodData::BankTransfer(_)
| PaymentMethodData::Crypto(_)
| PaymentMethodData::MandatePayment
| PaymentMethodData::Reward
| PaymentMethodData::RealTimePayment(_)
| PaymentMethodData::MobilePayment(_)
| PaymentMethodData::Upi(_)
| PaymentMethodData::Voucher(_)
| PaymentMethodData::OpenBanking(_)
| PaymentMethodData::GiftCard(_)
| PaymentMethodData::CardToken(_)
| PaymentMethodData::NetworkToken(_)
| PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {
Err(report!(errors::ConnectorError::NotImplemented(
get_unimplemented_payment_method_error_message(req.connector.as_str(),),
)))
}
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/klarna/transformers.rs" role="context" start="44" end="46">
pub struct KlarnaConnectorMetadataObject {
pub klarna_region: Option<KlarnaEndpoint>,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/datatrans.rs<|crate|> hyperswitch_connectors<|connector|> datatrans anchor=get_request_body kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/datatrans.rs" role="context" start="657" end="670">
fn get_request_body(
&self,
req: &RefundsRouterData<Execute>,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let amount = convert_amount(
self.amount_converter,
req.request.minor_refund_amount,
req.request.currency,
)?;
let connector_router_data = datatrans::DatatransRouterData::try_from((amount, req))?;
let connector_req = datatrans::DatatransRefundRequest::try_from(&connector_router_data)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/datatrans.rs" role="context" start="656" end="656">
}
fn get_url(
&self,
req: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let transaction_id = req.request.connector_transaction_id.clone();
let base_url = self.base_url(connectors);
Ok(format!("{base_url}v1/transactions/{transaction_id}/credit"))
}
fn get_request_body(
&self,
req: &RefundsRouterData<Execute>,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let amount = convert_amount(
self.amount_converter,
req.request.minor_refund_amount,
req.request.currency,
)?;
let connector_router_data = datatrans::DatatransRouterData::try_from((amount, req))?;
let connector_req = datatrans::DatatransRefundRequest::try_from(&connector_router_data)?;
Ok(RequestContent::Json(Box::new(connector_req)))
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/datatrans.rs" role="context" start="691" end="709">
fn handle_response(
&self,
data: &RefundsRouterData<Execute>,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundsRouterData<Execute>, errors::ConnectorError> {
let response: datatrans::DatatransRefundsResponse = res
.response
.parse_struct("datatrans DatatransRefundsResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/datatrans.rs" role="context" start="672" end="689">
fn build_request(
&self,
req: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Post)
.url(&types::RefundExecuteType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::RefundExecuteType::get_headers(
self, req, connectors,
)?)
.set_body(types::RefundExecuteType::get_request_body(
self, req, connectors,
)?)
.build();
Ok(Some(request))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/datatrans.rs" role="context" start="647" end="655">
fn get_url(
&self,
req: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let transaction_id = req.request.connector_transaction_id.clone();
let base_url = self.base_url(connectors);
Ok(format!("{base_url}v1/transactions/{transaction_id}/credit"))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/datatrans.rs" role="context" start="643" end="645">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/datatrans.rs" role="context" start="743" end="759">
fn build_request(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&types::RefundSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::RefundSyncType::get_headers(self, req, connectors)?)
.set_body(types::RefundSyncType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/datatrans.rs" role="context" start="512" end="530">
fn build_request(
&self,
req: &PaymentsCaptureRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsCaptureType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsCaptureType::get_headers(
self, req, connectors,
)?)
.set_body(types::PaymentsCaptureType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/datatrans.rs" role="context" start="76" end="80">
pub const fn new() -> &'static Self {
&Self {
amount_converter: &MinorUnitForConnector,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/datatrans/transformers.rs" role="context" start="48" end="51">
pub struct DatatransRouterData<T> {
pub amount: MinorUnit,
pub router_data: T,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/bluesnap.rs<|crate|> hyperswitch_connectors<|connector|> bluesnap anchor=get_request_body kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bluesnap.rs" role="context" start="922" end="935">
fn get_request_body(
&self,
req: &RefundsRouterData<Execute>,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let refund_amount = convert_amount(
self.amount_converter,
req.request.minor_refund_amount,
req.request.currency,
)?;
let connector_router_data = bluesnap::BluesnapRouterData::try_from((refund_amount, req))?;
let connector_req = bluesnap::BluesnapRefundRequest::try_from(&connector_router_data)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bluesnap.rs" role="context" start="921" end="921">
&self,
req: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}{}{}",
self.base_url(connectors),
"services/2/transactions/refund/",
req.request.connector_transaction_id
))
}
fn get_request_body(
&self,
req: &RefundsRouterData<Execute>,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let refund_amount = convert_amount(
self.amount_converter,
req.request.minor_refund_amount,
req.request.currency,
)?;
let connector_router_data = bluesnap::BluesnapRouterData::try_from((refund_amount, req))?;
let connector_req = bluesnap::BluesnapRefundRequest::try_from(&connector_router_data)?;
Ok(RequestContent::Json(Box::new(connector_req)))
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bluesnap.rs" role="context" start="956" end="974">
fn handle_response(
&self,
data: &RefundsRouterData<Execute>,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundsRouterData<Execute>, errors::ConnectorError> {
let response: bluesnap::RefundResponse = res
.response
.parse_struct("bluesnap RefundResponse")
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bluesnap.rs" role="context" start="937" end="954">
fn build_request(
&self,
req: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Post)
.url(&types::RefundExecuteType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::RefundExecuteType::get_headers(
self, req, connectors,
)?)
.set_body(types::RefundExecuteType::get_request_body(
self, req, connectors,
)?)
.build();
Ok(Some(request))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bluesnap.rs" role="context" start="909" end="920">
fn get_url(
&self,
req: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}{}{}",
self.base_url(connectors),
"services/2/transactions/refund/",
req.request.connector_transaction_id
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bluesnap.rs" role="context" start="905" end="907">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bluesnap.rs" role="context" start="337" end="352">
fn build_request(
&self,
req: &PaymentsCancelRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Put)
.url(&types::PaymentsVoidType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsVoidType::get_headers(self, req, connectors)?)
.set_body(types::PaymentsVoidType::get_request_body(
self, req, connectors,
)?)
.build();
Ok(Some(request))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bluesnap.rs" role="context" start="515" end="532">
fn build_request(
&self,
req: &PaymentsCaptureRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Put)
.url(&types::PaymentsCaptureType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsCaptureType::get_headers(
self, req, connectors,
)?)
.set_body(types::PaymentsCaptureType::get_request_body(
self, req, connectors,
)?)
.build();
Ok(Some(request))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bluesnap.rs" role="context" start="74" end="78">
pub fn new() -> &'static Self {
&Self {
amount_converter: &StringMajorUnitForConnector,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/bluesnap/transformers.rs" role="context" start="47" end="50">
pub struct BluesnapRouterData<T> {
pub amount: StringMajorUnit,
pub router_data: T,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/moneris.rs<|crate|> hyperswitch_connectors<|connector|> moneris anchor=get_request_body kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/moneris.rs" role="context" start="667" end="681">
fn get_request_body(
&self,
req: &RefundsRouterData<Execute>,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let refund_amount = utils::convert_amount(
self.amount_converter,
req.request.minor_refund_amount,
req.request.currency,
)?;
let connector_router_data = moneris::MonerisRouterData::from((refund_amount, req));
let connector_req = moneris::MonerisRefundRequest::try_from(&connector_router_data)?;
Ok(RequestContent::Json(Box::new(connector_req)))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/moneris.rs" role="context" start="666" end="666">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
fn get_url(
&self,
_req: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}/refunds", self.base_url(connectors)))
}
fn get_request_body(
&self,
req: &RefundsRouterData<Execute>,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let refund_amount = utils::convert_amount(
self.amount_converter,
req.request.minor_refund_amount,
req.request.currency,
)?;
let connector_router_data = moneris::MonerisRouterData::from((refund_amount, req));
let connector_req = moneris::MonerisRefundRequest::try_from(&connector_router_data)?;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/moneris.rs" role="context" start="702" end="719">
fn handle_response(
&self,
data: &RefundsRouterData<Execute>,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundsRouterData<Execute>, errors::ConnectorError> {
let response: moneris::RefundResponse = res
.response
.parse_struct("moneris RefundResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/moneris.rs" role="context" start="683" end="700">
fn build_request(
&self,
req: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Post)
.url(&types::RefundExecuteType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::RefundExecuteType::get_headers(
self, req, connectors,
)?)
.set_body(types::RefundExecuteType::get_request_body(
self, req, connectors,
)?)
.build();
Ok(Some(request))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/moneris.rs" role="context" start="659" end="665">
fn get_url(
&self,
_req: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!("{}/refunds", self.base_url(connectors)))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/moneris.rs" role="context" start="655" end="657">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/moneris.rs" role="context" start="752" end="768">
fn build_request(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&types::RefundSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::RefundSyncType::get_headers(self, req, connectors)?)
.set_body(types::RefundSyncType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/moneris.rs" role="context" start="362" end="382">
fn build_request(
&self,
req: &PaymentsAuthorizeRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsAuthorizeType::get_url(
self, req, connectors,
)?)
.attach_default_headers()
.headers(types::PaymentsAuthorizeType::get_headers(
self, req, connectors,
)?)
.set_body(types::PaymentsAuthorizeType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/moneris.rs" role="context" start="55" end="59">
pub fn new() -> &'static Self {
&Self {
amount_converter: &MinorUnitForConnector,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/moneris/transformers.rs" role="context" start="26" end="29">
pub struct MonerisRouterData<T> {
pub amount: MinorUnit, // The type of amount that a connector accepts, for example, String, i64, f64, etc.
pub router_data: T,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource.rs<|crate|> hyperswitch_connectors<|connector|> cybersource anchor=get_request_body kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource.rs" role="context" start="1645" end="1663">
fn get_request_body(
&self,
req: &PaymentsIncrementalAuthorizationRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let minor_additional_amount = MinorUnit::new(req.request.additional_amount);
let additional_amount = convert_amount(
self.amount_converter,
minor_additional_amount,
req.request.currency,
)?;
let connector_router_data =
cybersource::CybersourceRouterData::from((additional_amount, req));
let connector_request =
cybersource::CybersourcePaymentsIncrementalAuthorizationRequest::try_from(
&connector_router_data,
)?;
Ok(RequestContent::Json(Box::new(connector_request)))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource.rs" role="context" start="1644" end="1644">
&self,
req: &PaymentsIncrementalAuthorizationRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let connector_payment_id = req.request.connector_transaction_id.clone();
Ok(format!(
"{}pts/v2/payments/{}",
self.base_url(connectors),
connector_payment_id
))
}
fn get_request_body(
&self,
req: &PaymentsIncrementalAuthorizationRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let minor_additional_amount = MinorUnit::new(req.request.additional_amount);
let additional_amount = convert_amount(
self.amount_converter,
minor_additional_amount,
req.request.currency,
)?;
let connector_router_data =
cybersource::CybersourceRouterData::from((additional_amount, req));
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource.rs" role="context" start="1685" end="1710">
fn handle_response(
&self,
data: &PaymentsIncrementalAuthorizationRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<
RouterData<
IncrementalAuthorization,
PaymentsIncrementalAuthorizationData,
PaymentsResponseData,
>,
errors::ConnectorError,
> {
let response: cybersource::CybersourcePaymentsIncrementalAuthorizationResponse = res
.response
.parse_struct("Cybersource PaymentResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
.change_context(errors::ConnectorError::ResponseHandlingFailed)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource.rs" role="context" start="1664" end="1684">
fn build_request(
&self,
req: &PaymentsIncrementalAuthorizationRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Patch)
.url(&IncrementalAuthorizationType::get_url(
self, req, connectors,
)?)
.attach_default_headers()
.headers(IncrementalAuthorizationType::get_headers(
self, req, connectors,
)?)
.set_body(IncrementalAuthorizationType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource.rs" role="context" start="1632" end="1643">
fn get_url(
&self,
req: &PaymentsIncrementalAuthorizationRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let connector_payment_id = req.request.connector_transaction_id.clone();
Ok(format!(
"{}pts/v2/payments/{}",
self.base_url(connectors),
connector_payment_id
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource.rs" role="context" start="1628" end="1630">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource.rs" role="context" start="682" end="700">
fn build_request(
&self,
req: &PaymentsPreProcessingRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&PaymentsPreProcessingType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(PaymentsPreProcessingType::get_headers(
self, req, connectors,
)?)
.set_body(PaymentsPreProcessingType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource.rs" role="context" start="1120" end="1134">
fn build_request(
&self,
req: &PayoutsRouterData<PoFulfill>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Post)
.url(&PayoutFulfillType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(PayoutFulfillType::get_headers(self, req, connectors)?)
.set_body(PayoutFulfillType::get_request_body(self, req, connectors)?)
.build();
Ok(Some(request))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource.rs" role="context" start="89" end="93">
pub fn new() -> &'static Self {
&Self {
amount_converter: &StringMajorUnitForConnector,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/cybersource/transformers.rs" role="context" start="72" end="75">
pub struct CybersourceRouterData<T> {
pub amount: StringMajorUnit,
pub router_data: T,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/recurly.rs<|crate|> hyperswitch_connectors<|connector|> recurly anchor=get_url kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/recurly.rs" role="context" start="698" end="720">
fn get_url(
&self,
req: &recovery_router_data_types::RevenueRecoveryRecordBackRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let invoice_id = req
.request
.merchant_reference_id
.get_string_repr()
.to_string();
let status = RecurlyRecordStatus::try_from(req.request.attempt_status)?;
let status_endpoint = match status {
RecurlyRecordStatus::Success => STATUS_SUCCESSFUL_ENDPOINT,
RecurlyRecordStatus::Failure => STATUS_FAILED_ENDPOINT,
};
Ok(format!(
"{}/invoices/{invoice_id}/{status_endpoint}",
self.base_url(connectors)
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/recurly.rs" role="context" start="697" end="697">
use common_utils::{
consts,
errors::CustomResult,
ext_traits::BytesExt,
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, StringMinorUnit, StringMinorUnitForConnector},
};
use hyperswitch_domain_models::{
revenue_recovery, router_flow_types::revenue_recovery as recovery_router_flows,
router_request_types::revenue_recovery as recovery_request_types,
router_response_types::revenue_recovery as recovery_response_types,
types as recovery_router_data_types,
};
use hyperswitch_interfaces::{
api::{
self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorSpecifications,
ConnectorValidation,
},
configs::Connectors,
errors,
events::connector_api_logs::ConnectorEvent,
types::{self, Response},
webhooks,
};
use crate::connectors::recurly::transformers::{RecurlyRecordStatus, RecurlyRecoveryDetailsData};
use crate::{
connectors::recurly::transformers::RecurlyWebhookBody, constants::headers,
types::ResponseRouterData, utils,
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/recurly.rs" role="context" start="726" end="744">
fn build_request(
&self,
req: &recovery_router_data_types::RevenueRecoveryRecordBackRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Put)
.url(&types::RevenueRecoveryRecordBackType::get_url(
self, req, connectors,
)?)
.attach_default_headers()
.headers(types::RevenueRecoveryRecordBackType::get_headers(
self, req, connectors,
)?)
.header("Content-Length", "0")
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/recurly.rs" role="context" start="722" end="724">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/recurly.rs" role="context" start="691" end="697">
fn get_headers(
&self,
req: &recovery_router_data_types::RevenueRecoveryRecordBackRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/recurly.rs" role="context" start="674" end="680">
fn get_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
self.build_error_response(res, event_builder)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/recurly.rs" role="context" start="325" end="338">
fn build_request(
&self,
req: &PaymentsSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&types::PaymentsSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsSyncType::get_headers(self, req, connectors)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/recurly.rs" role="context" start="484" end="501">
fn build_request(
&self,
req: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Post)
.url(&types::RefundExecuteType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::RefundExecuteType::get_headers(
self, req, connectors,
)?)
.set_body(types::RefundExecuteType::get_request_body(
self, req, connectors,
)?)
.build();
Ok(Some(request))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/recurly/transformers.rs" role="context" start="418" end="421">
pub enum RecurlyRecordStatus {
Success,
Failure,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/hipay.rs<|crate|> hyperswitch_connectors<|connector|> hipay anchor=get_request_body kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/hipay.rs" role="context" start="613" end="630">
fn get_request_body(
&self,
req: &RefundsRouterData<Execute>,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let refund_amount = utils::convert_amount(
self.amount_converter,
req.request.minor_refund_amount,
req.request.currency,
)?;
let connector_router_data = hipay::HipayRouterData::from((refund_amount, req));
let connector_req = hipay::HipayMaintenanceRequest::try_from(&connector_router_data)?;
router_env::logger::info!(raw_connector_request=?connector_req);
let connector_req = build_form_from_struct(connector_req)
.change_context(errors::ConnectorError::ParsingFailed)?;
Ok(RequestContent::FormData(connector_req))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/hipay.rs" role="context" start="612" end="612">
use common_utils::{
consts::BASE64_ENGINE,
errors::{self as common_errors, CustomResult},
ext_traits::BytesExt,
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, StringMajorUnit, StringMajorUnitForConnector},
};
use hyperswitch_domain_models::{
router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
router_flow_types::{
access_token_auth::AccessTokenAuth,
payments::{Authorize, Capture, PSync, PaymentMethodToken, Session, SetupMandate, Void},
refunds::{Execute, RSync},
},
router_request_types::{
AccessTokenRequestData, PaymentMethodTokenizationData, PaymentsAuthorizeData,
PaymentsCancelData, PaymentsCaptureData, PaymentsSessionData, PaymentsSyncData,
RefundsData, SetupMandateRequestData,
},
router_response_types::{PaymentsResponseData, RefundsResponseData},
types::{
PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,
PaymentsSyncRouterData, RefundSyncRouterData, RefundsRouterData, TokenizationRouterData,
},
};
use hyperswitch_interfaces::{
api::{
self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorSpecifications,
ConnectorValidation,
},
configs::Connectors,
errors,
events::connector_api_logs::ConnectorEvent,
types::{self, Response, TokenizationType},
webhooks,
};
use transformers as hipay;
use crate::{constants::headers, types::ResponseRouterData, utils};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/hipay.rs" role="context" start="651" end="668">
fn handle_response(
&self,
data: &RefundsRouterData<Execute>,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<RefundsRouterData<Execute>, errors::ConnectorError> {
let response: hipay::HipayMaintenanceResponse<hipay::RefundStatus> = res
.response
.parse_struct("hipay RefundResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
RouterData::try_from(ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/hipay.rs" role="context" start="632" end="649">
fn build_request(
&self,
req: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Post)
.url(&types::RefundExecuteType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::RefundExecuteType::get_headers(
self, req, connectors,
)?)
.set_body(types::RefundExecuteType::get_request_body(
self, req, connectors,
)?)
.build();
Ok(Some(request))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/hipay.rs" role="context" start="601" end="611">
fn get_url(
&self,
req: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
Ok(format!(
"{}v1/maintenance/transaction/{}",
connectors.hipay.base_url.clone(),
req.request.connector_transaction_id
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/hipay.rs" role="context" start="593" end="599">
fn get_headers(
&self,
req: &RefundsRouterData<Execute>,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/hipay.rs" role="context" start="545" end="559">
fn build_request(
&self,
req: &PaymentsCancelRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
let request = RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsVoidType::get_url(self, req, connectors)?)
.headers(types::PaymentsVoidType::get_headers(self, req, connectors)?)
.set_body(types::PaymentsVoidType::get_request_body(
self, req, connectors,
)?)
.build();
Ok(Some(request))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/hipay.rs" role="context" start="701" end="717">
fn build_request(
&self,
req: &RefundSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&types::RefundSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::RefundSyncType::get_headers(self, req, connectors)?)
.set_body(types::RefundSyncType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/hipay.rs" role="context" start="49" end="73">
pub fn build_form_from_struct<T: Serialize>(data: T) -> Result<Form, common_errors::ParsingError> {
let mut form = Form::new();
let serialized = serde_json::to_value(&data).map_err(|e| {
router_env::logger::error!("Error serializing data to JSON value: {:?}", e);
common_errors::ParsingError::EncodeError("json-value")
})?;
let serialized_object = serialized.as_object().ok_or_else(|| {
router_env::logger::error!("Error: Expected JSON object but got something else");
common_errors::ParsingError::EncodeError("Expected object")
})?;
for (key, values) in serialized_object {
let value = match values {
Value::String(s) => s.clone(),
Value::Number(n) => n.to_string(),
Value::Bool(b) => b.to_string(),
Value::Null => "".to_string(),
Value::Array(_) | Value::Object(_) => {
router_env::logger::error!(serialization_error =? "Form Construction Failed.");
"".to_string()
}
};
form = form.text(key.clone(), value.clone());
}
Ok(form)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/hipay/transformers.rs" role="context" start="39" end="42">
pub struct HipayRouterData<T> {
pub amount: StringMajorUnit,
pub router_data: T,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/stripebilling.rs<|crate|> hyperswitch_connectors<|connector|> stripebilling anchor=get_url kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/stripebilling.rs" role="context" start="683" end="704">
fn get_url(
&self,
req: &recovery_router_data_types::RevenueRecoveryRecordBackRouterData,
connectors: &Connectors,
) -> CustomResult<String, errors::ConnectorError> {
let invoice_id = req
.request
.merchant_reference_id
.get_string_repr()
.to_string();
match req.request.attempt_status {
common_enums::AttemptStatus::Charged => Ok(format!(
"{}/v1/invoices/{invoice_id}/pay?paid_out_of_band=true",
self.base_url(connectors),
)),
common_enums::AttemptStatus::Failure => Ok(format!(
"{}/v1/invoices/{invoice_id}/void",
self.base_url(connectors),
)),
_ => Err(errors::ConnectorError::FailedToObtainIntegrationUrl.into()),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/stripebilling.rs" role="context" start="682" end="682">
use common_utils::{
errors::CustomResult,
ext_traits::BytesExt,
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, StringMinorUnit, StringMinorUnitForConnector},
};
use hyperswitch_domain_models::{
router_flow_types::revenue_recovery as recovery_router_flows,
router_request_types::revenue_recovery as recovery_request_types,
router_response_types::revenue_recovery as recovery_response_types,
types as recovery_router_data_types,
};
use hyperswitch_interfaces::{
api::{
self, ConnectorCommon, ConnectorCommonExt, ConnectorIntegration, ConnectorSpecifications,
ConnectorValidation,
},
configs::Connectors,
errors,
events::connector_api_logs::ConnectorEvent,
types::{self, Response},
webhooks,
};
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/stripebilling.rs" role="context" start="725" end="749">
fn handle_response(
&self,
data: &recovery_router_data_types::RevenueRecoveryRecordBackRouterData,
event_builder: Option<&mut ConnectorEvent>,
res: Response,
) -> CustomResult<
recovery_router_data_types::RevenueRecoveryRecordBackRouterData,
errors::ConnectorError,
> {
let response = res
.response
.parse_struct::<stripebilling::StripebillingRecordBackResponse>(
"StripebillingRecordBackResponse",
)
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
recovery_router_data_types::RevenueRecoveryRecordBackRouterData::try_from(
ResponseRouterData {
response,
data: data.clone(),
http_code: res.status_code,
},
)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/stripebilling.rs" role="context" start="706" end="723">
fn build_request(
&self,
req: &recovery_router_data_types::RevenueRecoveryRecordBackRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::RevenueRecoveryRecordBackType::get_url(
self, req, connectors,
)?)
.attach_default_headers()
.headers(types::RevenueRecoveryRecordBackType::get_headers(
self, req, connectors,
)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/stripebilling.rs" role="context" start="679" end="681">
fn get_content_type(&self) -> &'static str {
self.common_get_content_type()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/stripebilling.rs" role="context" start="671" end="677">
fn get_headers(
&self,
req: &recovery_router_data_types::RevenueRecoveryRecordBackRouterData,
connectors: &Connectors,
) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
self.build_headers(req, connectors)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/stripebilling.rs" role="context" start="301" end="314">
fn build_request(
&self,
req: &PaymentsSyncRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Get)
.url(&types::PaymentsSyncType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsSyncType::get_headers(self, req, connectors)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/stripebilling.rs" role="context" start="373" end="391">
fn build_request(
&self,
req: &PaymentsCaptureRouterData,
connectors: &Connectors,
) -> CustomResult<Option<Request>, errors::ConnectorError> {
Ok(Some(
RequestBuilder::new()
.method(Method::Post)
.url(&types::PaymentsCaptureType::get_url(self, req, connectors)?)
.attach_default_headers()
.headers(types::PaymentsCaptureType::get_headers(
self, req, connectors,
)?)
.set_body(types::PaymentsCaptureType::get_request_body(
self, req, connectors,
)?)
.build(),
))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/aci/transformers.rs" role="context" start="642" end="642">
type Err = error_stack::Report<errors::ConnectorError>;
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu.rs<|crate|> hyperswitch_connectors<|connector|> fiuu anchor=build_form_from_struct kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu.rs" role="context" start="244" end="267">
pub fn build_form_from_struct<T: Serialize>(data: T) -> Result<Form, common_errors::ParsingError> {
let mut form = Form::new();
let serialized = serde_json::to_value(&data).map_err(|e| {
router_env::logger::error!("Error serializing data to JSON value: {:?}", e);
common_errors::ParsingError::EncodeError("json-value")
})?;
let serialized_object = serialized.as_object().ok_or_else(|| {
router_env::logger::error!("Error: Expected JSON object but got something else");
common_errors::ParsingError::EncodeError("Expected object")
})?;
for (key, values) in serialized_object {
let value = match values {
Value::String(s) => s.clone(),
Value::Number(n) => n.to_string(),
Value::Bool(b) => b.to_string(),
Value::Array(_) | Value::Object(_) | Value::Null => {
router_env::logger::error!(serialization_error =? "Form Construction Failed.");
"".to_string()
}
};
form = form.text(key.clone(), value.clone());
}
Ok(form)
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu.rs" role="context" start="243" end="243">
use common_utils::{
crypto::{self, GenerateDigest},
errors::{self as common_errors, CustomResult},
ext_traits::{ByteSliceExt, BytesExt},
request::{Method, Request, RequestBuilder, RequestContent},
types::{AmountConvertor, StringMajorUnit, StringMajorUnitForConnector},
};
use serde::{Deserialize, Serialize};
use serde_json::Value;
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu.rs" role="context" start="286" end="294">
fn validate_mandate_payment(
&self,
pm_type: Option<PaymentMethodType>,
pm_data: PaymentMethodData,
) -> CustomResult<(), errors::ConnectorError> {
let mandate_supported_pmd: HashSet<PaymentMethodDataType> =
HashSet::from([PaymentMethodDataType::Card]);
utils::is_mandate_supported(pm_data, pm_type, mandate_supported_pmd, self.id())
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu.rs" role="context" start="270" end="285">
fn validate_connector_against_payment_request(
&self,
capture_method: Option<CaptureMethod>,
_payment_method: PaymentMethod,
_pmt: Option<PaymentMethodType>,
) -> CustomResult<(), errors::ConnectorError> {
let capture_method = capture_method.unwrap_or_default();
match capture_method {
CaptureMethod::Automatic
| CaptureMethod::Manual
| CaptureMethod::SequentialAutomatic => Ok(()),
CaptureMethod::ManualMultiple | CaptureMethod::Scheduled => Err(
utils::construct_not_implemented_error_report(capture_method, self.id()),
),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu.rs" role="context" start="218" end="242">
fn build_error_response(
&self,
res: Response,
event_builder: Option<&mut ConnectorEvent>,
) -> CustomResult<ErrorResponse, errors::ConnectorError> {
let response: fiuu::FiuuErrorResponse = res
.response
.parse_struct("FiuuErrorResponse")
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
event_builder.map(|i| i.set_response_body(&response));
router_env::logger::info!(connector_response=?response);
Ok(ErrorResponse {
status_code: res.status_code,
code: response.error_code.clone(),
message: response.error_desc.clone(),
reason: Some(response.error_desc.clone()),
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu.rs" role="context" start="214" end="216">
fn base_url<'a>(&self, connectors: &'a Connectors) -> &'a str {
connectors.fiuu.base_url.as_ref()
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu.rs" role="context" start="604" end="612">
fn get_request_body(
&self,
req: &PaymentsCancelRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let connector_req = build_form_from_struct(fiuu::FiuuPaymentCancelRequest::try_from(req)?)
.change_context(errors::ConnectorError::ParsingFailed)?;
Ok(RequestContent::FormData(connector_req))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu.rs" role="context" start="340" end="372">
fn get_request_body(
&self,
req: &PaymentsAuthorizeRouterData,
_connectors: &Connectors,
) -> CustomResult<RequestContent, errors::ConnectorError> {
let amount = utils::convert_amount(
self.amount_converter,
req.request.minor_amount,
req.request.currency,
)?;
let connector_router_data = fiuu::FiuuRouterData::from((amount, req));
let optional_is_mit_flow = req.request.off_session;
let optional_is_nti_flow = req
.request
.mandate_id
.as_ref()
.map(|mandate_id| mandate_id.is_network_transaction_id_flow());
let connector_req = match (optional_is_mit_flow, optional_is_nti_flow) {
(Some(true), Some(false)) => {
let recurring_request = fiuu::FiuuMandateRequest::try_from(&connector_router_data)?;
build_form_from_struct(recurring_request)
.change_context(errors::ConnectorError::ParsingFailed)?
}
_ => {
let payment_request = fiuu::FiuuPaymentRequest::try_from(&connector_router_data)?;
build_form_from_struct(payment_request)
.change_context(errors::ConnectorError::ParsingFailed)?
}
};
Ok(RequestContent::FormData(connector_req))
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/fiuu.rs" role="context" start="162" end="166">
pub fn new() -> &'static Self {
&Self {
amount_converter: &StringMajorUnitForConnector,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/utils.rs" role="context" start="74" end="74">
type Error = error_stack::Report<errors::ConnectorError>;
<file_sep path="hyperswitch/crates/api_models/src/payment_methods.rs" role="context" start="2478" end="2478">
type Error = error_stack::Report<errors::ValidationError>;
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/paybox/transformers.rs<|crate|> hyperswitch_connectors<|connector|> paybox anchor=get_status_of_request kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=1<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paybox/transformers.rs" role="context" start="888" end="890">
fn get_status_of_request(item: String) -> bool {
item == *SUCCESS_CODE
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paybox/transformers.rs" role="context" start="928" end="955">
fn try_from(
item: RefundsResponseRouterData<RSync, PayboxSyncResponse>,
) -> Result<Self, Self::Error> {
let status = get_status_of_request(item.response.response_code.clone());
match status {
true => Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.transaction_number,
refund_status: enums::RefundStatus::from(item.response.status),
}),
..item.data
}),
false => Ok(Self {
response: Err(ErrorResponse {
code: item.response.response_code.clone(),
message: item.response.response_message.clone(),
reason: Some(item.response.response_message),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(item.response.transaction_number),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
}),
..item.data
}),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paybox/transformers.rs" role="context" start="894" end="921">
fn try_from(
item: &PayboxRouterData<&types::RefundsRouterData<F>>,
) -> Result<Self, Self::Error> {
let auth_data: PayboxAuthType =
PayboxAuthType::try_from(&item.router_data.connector_auth_type)
.change_context(errors::ConnectorError::FailedToObtainAuthType)?;
let currency = enums::Currency::iso_4217(item.router_data.request.currency).to_string();
let format_time = common_utils::date_time::format_date(
common_utils::date_time::now(),
DateFormat::DDMMYYYYHHmmss,
)
.change_context(errors::ConnectorError::RequestEncodingFailed)?;
let paybox_meta_data: PayboxMeta =
utils::to_connector_meta(item.router_data.request.connector_metadata.clone())?;
Ok(Self {
date: format_time.clone(),
transaction_type: REFUND_REQUEST.to_string(),
paybox_request_number: get_paybox_request_number()?,
version: VERSION_PAYBOX.to_string(),
currency,
site: auth_data.site,
rank: auth_data.rang,
key: auth_data.cle,
transaction_number: paybox_meta_data.connector_request_id,
paybox_order_id: item.router_data.request.connector_transaction_id.clone(),
amount: item.amount,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paybox/transformers.rs" role="context" start="879" end="886">
fn from(item: PayboxStatus) -> Self {
match item {
PayboxStatus::Cancelled => Self::Voided,
PayboxStatus::Authorised => Self::Authorized,
PayboxStatus::Captured | PayboxStatus::Refunded => Self::Charged,
PayboxStatus::Rejected => Self::Failure,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paybox/transformers.rs" role="context" start="868" end="876">
fn from(item: PayboxStatus) -> Self {
match item {
PayboxStatus::Refunded => Self::Success,
PayboxStatus::Cancelled
| PayboxStatus::Authorised
| PayboxStatus::Captured
| PayboxStatus::Rejected => Self::Failure,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paybox/transformers.rs" role="context" start="732" end="818">
fn try_from(
item: ResponseRouterData<F, PayboxResponse, PaymentsAuthorizeData, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
match item.response.clone() {
PayboxResponse::NonThreeDs(response) => {
let status: bool = get_status_of_request(response.response_code.clone());
match status {
true => Ok(Self {
status: match (
item.data.request.is_auto_capture()?,
item.data.request.is_cit_mandate_payment(),
) {
(_, true) | (false, false) => enums::AttemptStatus::Authorized,
(true, false) => enums::AttemptStatus::Charged,
},
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
response.paybox_order_id,
),
redirection_data: Box::new(None),
mandate_reference: Box::new(response.carrier_id.as_ref().map(
|pm: &Secret<String>| MandateReference {
connector_mandate_id: Some(pm.clone().expose()),
payment_method_id: None,
mandate_metadata: None,
connector_mandate_request_reference_id:
response.customer_id.map(|secret| secret.expose()),
},
)),
connector_metadata: Some(serde_json::json!(PayboxMeta {
connector_request_id: response.transaction_number.clone()
})),
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
}),
false => Ok(Self {
response: Err(ErrorResponse {
code: response.response_code.clone(),
message: response.response_message.clone(),
reason: Some(response.response_message),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(response.transaction_number),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
}),
..item.data
}),
}
}
PayboxResponse::ThreeDs(data) => Ok(Self {
status: enums::AttemptStatus::AuthenticationPending,
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::NoResponseId,
redirection_data: Box::new(Some(RedirectForm::Html {
html_data: data.peek().to_string(),
})),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
}),
PayboxResponse::Error(_) => Ok(Self {
response: Err(ErrorResponse {
code: NO_ERROR_CODE.to_string(),
message: NO_ERROR_MESSAGE.to_string(),
reason: Some(NO_ERROR_MESSAGE.to_string()),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: None,
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
}),
..item.data
}),
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/paybox/transformers.rs" role="context" start="825" end="864">
fn try_from(
item: ResponseRouterData<F, PayboxSyncResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let response = item.response.clone();
let status = get_status_of_request(response.response_code.clone());
let connector_payment_status = item.response.status;
match status {
true => Ok(Self {
status: enums::AttemptStatus::from(connector_payment_status),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(response.paybox_order_id),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: Some(serde_json::json!(PayboxMeta {
connector_request_id: response.transaction_number.clone()
})),
network_txn_id: None,
connector_response_reference_id: None,
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
}),
false => Ok(Self {
response: Err(ErrorResponse {
code: response.response_code.clone(),
message: response.response_message.clone(),
reason: Some(response.response_message),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(item.response.transaction_number),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
}),
..item.data
}),
}
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/razorpay/transformers.rs<|crate|> hyperswitch_connectors<|connector|> razorpay anchor=from kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/razorpay/transformers.rs" role="context" start="1210" end="1216">
fn from(item: RefundStatus) -> Self {
match item {
RefundStatus::Success => Self::Success,
RefundStatus::Failure => Self::Failure,
RefundStatus::Pending => Self::Pending,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/razorpay/transformers.rs" role="context" start="1290" end="1305">
fn try_from(
item: RefundsResponseRouterData<RSync, RefundResponse>,
) -> Result<Self, Self::Error> {
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item
.data
.request
.connector_refund_id
.clone()
.ok_or(errors::ConnectorError::MissingConnectorRefundID)?,
refund_status: enums::RefundStatus::from(item.response.refund.status),
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/razorpay/transformers.rs" role="context" start="1248" end="1285">
fn try_from(
item: RefundsResponseRouterData<Execute, RefundResponse>,
) -> Result<Self, Self::Error> {
let epg_txn_id = item.response.refund.epg_txn_id.clone();
let refund_status = enums::RefundStatus::from(item.response.refund.status);
let response = match epg_txn_id {
Some(epg_txn_id) => Ok(RefundsResponseData {
connector_refund_id: epg_txn_id,
refund_status,
}),
None => Err(hyperswitch_domain_models::router_data::ErrorResponse {
code: item
.response
.refund
.error_message
.clone()
.unwrap_or(NO_ERROR_CODE.to_string()),
message: item
.response
.refund
.response_code
.clone()
.unwrap_or(NO_ERROR_MESSAGE.to_string()),
reason: item.response.refund.response_code.clone(),
status_code: item.http_code,
attempt_status: None,
connector_transaction_id: Some(item.response.refund.unique_request_id.clone()),
network_advice_code: None,
network_decline_code: None,
network_error_message: None,
}),
};
Ok(Self {
response,
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/razorpay/transformers.rs" role="context" start="1076" end="1206">
fn try_from(
(item, data): (
&RazorpayRouterData<&types::RefundsRouterData<F>>,
&Connectors,
),
) -> Result<Self, Self::Error> {
let ref_id = generate_12_digit_number();
let auth = RazorpayAuthType::try_from(&item.router_data.connector_auth_type)?;
let merchant_data = JuspayAuthData::try_from(data)?;
let connector_transaction_id = item.router_data.request.connector_transaction_id.clone();
let connector_request_reference_id = &item.router_data.connector_request_reference_id;
let order_metadata_v2 = OrderMetadataV2 {
id: ref_id.to_string(),
order_reference_id: ref_id.to_string(),
date_created: Some(common_utils::date_time::now()),
last_updated: Some(common_utils::date_time::now()),
..Default::default()
};
let second_factor = SecondFactor {
txn_id: connector_request_reference_id.clone(),
id: ref_id.to_string(),
status: SecondFactorStatus::Pending,
version: VERSION,
sf_type: SecondFactorType::Vbv,
date_created: Some(common_utils::date_time::now()),
last_updated: Some(common_utils::date_time::now()),
epg_txn_id: Some(connector_transaction_id.clone()),
..Default::default()
};
let order_reference = OrderReference {
id: ref_id.to_string(),
amount: item.amount,
currency: item.router_data.request.currency.to_string(),
status: OrderStatus::Success,
merchant_id: merchant_data.merchant_id.clone(),
order_id: connector_request_reference_id.clone(),
version: VERSION,
order_type: OrderType::OrderPayment,
order_uuid: uuid::Uuid::new_v4().to_string(),
date_created: Some(common_utils::date_time::now()),
last_modified: Some(common_utils::date_time::now()),
..Default::default()
};
let txn_mode: TxnMode = match item.router_data.test_mode {
Some(true) | None => TxnMode::Test,
Some(false) => TxnMode::Prod,
};
let txn_detail = TxnDetail {
order_id: connector_request_reference_id.clone(),
express_checkout: false,
txn_mode,
merchant_id: merchant_data.merchant_id.clone(),
status: TxnStatus::from(item.router_data.status),
net_amount: item.amount,
txn_id: connector_request_reference_id.clone(),
txn_amount: item.amount,
emi_tenure: 0,
txn_uuid: uuid::Uuid::new_v4().to_string(),
id: ref_id.to_string(),
merchant_gateway_account_id: 11476,
txn_type: TxnType::AuthAndSettle,
redirect: true,
version: VERSION,
add_to_locker: false,
currency: item.router_data.request.currency.to_string(),
is_emi: false,
gateway: Gateway::Razorpay,
date_created: Some(common_utils::date_time::now()),
last_modified: Some(common_utils::date_time::now()),
..Default::default()
};
let refund = Refund {
id: ref_id,
status: RefundStatus::Pending,
amount: item.amount,
merchant_id: Some(merchant_data.merchant_id.clone()),
gateway: Gateway::Razorpay,
txn_detail_id: ref_id,
unique_request_id: item.router_data.request.refund_id.clone(),
processed: false,
date_created: Some(common_utils::date_time::now()),
};
let payment_gateway_response = PaymentGatewayResponse {
id: ref_id.to_string(),
version: VERSION,
};
let payment_source: Secret<String, pii::UpiVpaMaskingStrategy> =
Secret::new("".to_string());
let pm = enums::PaymentMethod::Upi;
let txn_card_info = TxnCardInfo {
txn_detail_id: ref_id.to_string(),
txn_id: item.router_data.connector_request_reference_id.clone(),
payment_method_type: pm.to_string().to_uppercase(),
id: ref_id.to_string(),
payment_method: pm.to_string().to_uppercase(),
payment_source,
date_created: Some(common_utils::date_time::now()),
..Default::default()
};
let account_details = AccountDetails {
razorpay_id: auth.razorpay_id.clone(),
razorpay_secret: auth.razorpay_secret,
};
let merchant_gateway_account = MerchantGatewayAccount {
gateway: Gateway::Razorpay,
disabled: false,
id: ref_id,
account_details: serde_json::to_string(&account_details)
.change_context(errors::ConnectorError::ParsingFailed)?,
test_mode: false,
merchant_id: merchant_data.merchant_id,
..Default::default()
};
Ok(Self {
order_metadata_v2,
second_factor,
order_reference,
txn_detail,
refund,
payment_gateway_response,
txn_card_info,
merchant_gateway_account,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/razorpay/transformers.rs" role="context" start="1003" end="1022">
fn try_from(
item: ResponseRouterData<F, RazorpaySyncResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
Ok(Self {
status: enums::AttemptStatus::from(item.response.status),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(
item.response.second_factor.epg_txn_id,
),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: Some(item.response.second_factor.txn_id),
incremental_authorization_allowed: None,
charges: None,
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/razorpay/transformers.rs" role="context" start="868" end="970">
fn try_from(
(item, data): (
RazorpayRouterData<&types::PaymentsSyncRouterData>,
&Connectors,
),
) -> Result<Self, Self::Error> {
let ref_id = generate_12_digit_number();
let auth = RazorpayAuthType::try_from(&item.router_data.connector_auth_type)?;
let merchant_data = JuspayAuthData::try_from(data)?;
let connector_transaction_id = item
.router_data
.request
.connector_transaction_id
.get_connector_transaction_id()
.change_context(errors::ConnectorError::MissingConnectorTransactionID)?;
let connector_request_reference_id = &item.router_data.connector_request_reference_id;
let second_factor = SecondFactor {
txn_id: connector_request_reference_id.clone(),
id: ref_id.to_string(),
status: SecondFactorStatus::Pending,
version: VERSION,
sf_type: SecondFactorType::Vbv,
date_created: Some(common_utils::date_time::now()),
last_updated: Some(common_utils::date_time::now()),
epg_txn_id: Some(connector_transaction_id.clone()),
..Default::default()
};
let order_reference = OrderReference {
id: ref_id.to_string(),
amount: item.amount,
currency: item.router_data.request.currency.to_string(),
status: OrderStatus::PendingAuthentication,
merchant_id: merchant_data.merchant_id.clone(),
order_id: connector_request_reference_id.clone(),
version: VERSION,
order_type: OrderType::OrderPayment,
order_uuid: uuid::Uuid::new_v4().to_string(),
date_created: Some(common_utils::date_time::now()),
last_modified: Some(common_utils::date_time::now()),
..Default::default()
};
let txn_mode: TxnMode = match item.router_data.test_mode {
Some(true) | None => TxnMode::Test,
Some(false) => TxnMode::Prod,
};
let txn_detail = TxnDetail {
order_id: connector_request_reference_id.clone(),
express_checkout: false,
txn_mode,
merchant_id: merchant_data.merchant_id.clone(),
status: TxnStatus::from(item.router_data.status),
net_amount: item.amount,
txn_id: connector_request_reference_id.clone(),
txn_amount: item.amount,
emi_tenure: 0,
txn_uuid: uuid::Uuid::new_v4().to_string(),
id: ref_id.to_string(),
merchant_gateway_account_id: 11476,
txn_type: TxnType::AuthAndSettle,
redirect: true,
version: VERSION,
add_to_locker: false,
currency: item.router_data.request.currency.to_string(),
is_emi: false,
gateway: Gateway::Razorpay,
date_created: Some(common_utils::date_time::now()),
last_modified: Some(common_utils::date_time::now()),
..Default::default()
};
let account_details = AccountDetails {
razorpay_id: auth.razorpay_id.clone(),
razorpay_secret: auth.razorpay_secret,
};
let merchant_gateway_account = MerchantGatewayAccount {
gateway: Gateway::Razorpay,
disabled: false,
id: ref_id,
account_details: serde_json::to_string(&account_details)
.change_context(errors::ConnectorError::ParsingFailed)?,
test_mode: false,
merchant_id: merchant_data.merchant_id,
..Default::default()
};
let gateway_txn_data = GatewayTxnData {
id: ref_id.to_string(),
version: VERSION,
gateway_data: "".to_string(),
gateway_status: "S".to_string(),
match_status: "S".to_string(),
txn_detail_id: ref_id.to_string(),
date_created: Some(common_utils::date_time::now()),
last_updated: Some(common_utils::date_time::now()),
};
Ok(Self {
second_factor,
merchant_gateway_account,
order_reference,
txn_detail,
gateway_txn_data,
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/razorpay/transformers.rs" role="context" start="1055" end="1060">
pub enum RefundStatus {
Success,
Failure,
#[default]
Pending,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
<|meta_start|><|file|> hyperswitch/crates/hyperswitch_connectors/src/connectors/payu/transformers.rs<|crate|> hyperswitch_connectors<|connector|> payu anchor=from kind=fn pack=symbol_neighborhood lang=rust role_window=k3 hops=2<|meta_end|>
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payu/transformers.rs" role="context" start="551" end="557">
fn from(item: RefundStatus) -> Self {
match item {
RefundStatus::Finalized | RefundStatus::Completed => Self::Success,
RefundStatus::Canceled => Self::Failure,
RefundStatus::Pending => Self::Pending,
}
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payu/transformers.rs" role="context" start="605" end="619">
fn try_from(
item: RefundsResponseRouterData<RSync, RefundSyncResponse>,
) -> Result<Self, Self::Error> {
let refund = match item.response.refunds.first() {
Some(refund) => refund,
_ => Err(errors::ConnectorError::ResponseHandlingFailed)?,
};
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: refund.refund_id.clone(),
refund_status: enums::RefundStatus::from(refund.status.clone()),
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payu/transformers.rs" role="context" start="583" end="594">
fn try_from(
item: RefundsResponseRouterData<Execute, RefundResponse>,
) -> Result<Self, Self::Error> {
let refund_status = enums::RefundStatus::from(item.response.refund.status);
Ok(Self {
response: Ok(RefundsResponseData {
connector_refund_id: item.response.refund.refund_id,
refund_status,
}),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payu/transformers.rs" role="context" start="523" end="534">
fn try_from(item: &PayuRouterData<&types::RefundsRouterData<F>>) -> Result<Self, Self::Error> {
Ok(Self {
refund: PayuRefundRequestData {
description: item.router_data.request.reason.clone().ok_or(
errors::ConnectorError::MissingRequiredField {
field_name: "item.request.reason",
},
)?,
amount: None,
},
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payu/transformers.rs" role="context" start="477" end="507">
fn try_from(
item: ResponseRouterData<F, PayuPaymentsSyncResponse, T, PaymentsResponseData>,
) -> Result<Self, Self::Error> {
let order = match item.response.orders.first() {
Some(order) => order,
_ => Err(errors::ConnectorError::ResponseHandlingFailed)?,
};
Ok(Self {
status: enums::AttemptStatus::from(order.status.clone()),
response: Ok(PaymentsResponseData::TransactionResponse {
resource_id: ResponseId::ConnectorTransactionId(order.order_id.clone()),
redirection_data: Box::new(None),
mandate_reference: Box::new(None),
connector_metadata: None,
network_txn_id: None,
connector_response_reference_id: order
.ext_order_id
.clone()
.or(Some(order.order_id.clone())),
incremental_authorization_allowed: None,
charges: None,
}),
amount_captured: Some(
order
.total_amount
.parse::<i64>()
.change_context(errors::ConnectorError::ResponseDeserializationFailed)?,
),
..item.data
})
}
<file_sep path="hyperswitch/crates/hyperswitch_connectors/src/connectors/payu/transformers.rs" role="context" start="542" end="548">
pub enum RefundStatus {
Finalized,
Completed,
Canceled,
#[default]
Pending,
}
<file_sep path="hyperswitch/crates/api_models/src/refunds.rs" role="context" start="378" end="384">
pub enum RefundStatus {
Succeeded,
Failed,
#[default]
Pending,
Review,
}
|
symbol_neighborhood
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.